Drupal 7: Les implémentations de hook sont mises en cache dans la base de données
Apparemment Drupal 7 cache ses implémentations de hook. Ainsi, lors de l'implémentation d'un hook dans D7 vous avez besoin de vider le cache.
Vous pouvez lire dans la fonction module_implements la raison pour laquelle cela est fait:
<?php
<?Php
function module_implements($hook, $sort = FALSE, $reset = FALSE) {
// Utilisez le modèle avancé drupal_static() , puisqu'il est appelé très souvent.
static $drupal_static_fast;
if (!isset($drupal_static_fast)) {
$drupal_static_fast['implementations'] = &drupal_static(__FUNCTION__);
}
$implementations = &$drupal_static_fast['implementations'];
// Nous maintenons un cache persistant des implémentations hook en plus de la
// Cache statique pour éviter le bouclage à travers chaque module et chaque hook sur chaque
// Requête. Benchmarks montrent que le bénéfice de cette mise en cache l'emporte sur la
// Base de données supplémentaire touché, même en utilisant la mise en cache de données par défaut
// Backend et seulement un petit nombre de modules sont activés. Le coût de la
// Cache_get () est plus ou moins constant et se réduit davantage lorsqu'il n'y a pas de base de données
// Backends de cache sont utilisées, il y aura donc des gains plus importants quand un
// Grand nombre de modules sont installés ou des hooks invoquées, car cela peut
// Rapidement conduire à module_hook () étant appelée plusieurs milliers de fois
// Par requête.
if ($reset) {
$implementations = array();
cache_set('module_implements', array(), 'cache_bootstrap');
drupal_static_reset('module_hook_info');
drupal_static_reset('drupal_alter');
cache_clear_all('hook_info', 'cache_bootstrap');
return;
}
//Retourner les implémentations du cache.
if (empty($implementations)) {
$implementations = cache_get('module_implements', 'cache_bootstrap');
if ($implementations === FALSE) {
$implementations = array();
}
else {
$implementations = $implementations->data;
}
}
if (!isset($implementations[$hook])) {
// Le hook n'est pas mis en cache, pour s'assurer s'il a ou non
// Les implémentations, que le cache est mis à jour à la fin de la requête.
$implementations['#write_cache'] = TRUE;
$hook_info = module_hook_info();
$implementations[$hook] = array();
$list = module_list(FALSE, FALSE, $sort);
foreach ($list as $module) {
$include_file = isset($hook_info[$hook]['group']) && module_load_include('inc', $module, $module . '.' . $hook_info[$hook]['group']);
// Vu que module_hook () peut tenter de charger inutilement le fichier include à nouveau,
// Function_exists () est utilisée directement ici.
if (function_exists($module . '_' . $hook)) {
$implementations[$hook][$module] = $include_file ? $hook_info[$hook]['group'] : FALSE;
}
}
// Autoriser les modules de changer le poids d'implémentations spécifiques mais il faut éviter
// Une boucle infinie.
if ($hook != 'module_implements_alter') {
drupal_alter('module_implements', $implementations[$hook], $hook);
}
}
else {
foreach ($implementations[$hook] as $module => $group) {
// Si cette mise en œuvre hook est stockée dans un fichier chargé lentement, on peut inclure
// ce fichier en premier.
if ($group) {
module_load_include('inc', $module, "$module.$group");
}
// Il est possible qu'un module enlève une mise en œuvre d'un hook sans
// L'implémentations de cache ne soit déjà reconstruite, alors nous vérifions si la
// Fonction existe sur chaque requête afin d'éviter des erreurs de type "undefined function".
// Vu que module_hook() peut tenter de charger inutilement le fichier include à nouveau,
// Function_exists() est utilisée directement ici.
if (!function_exists($module . '_' . $hook)) {
// Efface la mise en œuvre vicié de la mémoire cache et force un cache
// Actualiser pour oublier les implémentations de hooks n'existant plus .
unset($implementations[$hook][$module]);
$implementations['#write_cache'] = TRUE;
}
}
}
return array_keys($implementations[$hook]);
}
?>Ce fut la façon dont il a été fait dans drupal6. Il utilise juste le cache statique:
<?php
function module_implements($hook, $sort = FALSE, $refresh = FALSE) {
static $implementations;
if ($refresh) {
$implementations = array();
return;
}
if (!isset($implementations[$hook])) {
$implementations[$hook] = array();
$list = module_list(FALSE, TRUE, $sort);
foreach ($list as $module) {
if (module_hook($module, $hook)) {
$implementations[$hook][] = $module;
}
}
}
// La conversion explicite force une copie à être faite. Ceci est nécessaire parceque
// $ Implémentations [$ hook] est seulement une référence à un élément de
// $ Implémentations et s'il ya des foreaches imbriquées (à cause de nœud imbriqué
// d'Appels API, par exemple), ils manipuleraient à la fois les mêmes Références Array
// ce qui provoque que des crochets de certains modules ne soient pas appelés.
// Voir aussi http://www.zend.com/zend/art/ref-count.php.
return (array) $implementations[$hook];
}
?>Submitted by Dominique De Cooman on Sat, 2011-09-10 11:59
