Cette tâche vous permet de définir des objets mémorisables dans le fichier cachespec.xml,
qui se trouve dans le répertoire du module Web WEB-INF ou du bean enterprise META-INF.
Avant de commencer
Activez le cache dynamique. Pour plus d'informations,
reportez-vous à l'article Utilisation du service de cache dynamique.
Pourquoi et quand exécuter cette tâche
Vous pouvez sauvegarder un fichier cachespec.xml global dans le répertoire des propriétés du serveur d'applications, mais il est conseillé de placer le fichier de configuration de cache avec le module de déploiement ;
L'élément racine du fichier cachespec.xml est <cache> qui contient des éléments <cache-entry>.
Eviter les incidents: Lorsque le répertoire de propriétés du serveur d'applications contient un fichier
cachespec.xml global
et qu'une application contient un fichier
cachespec.xml,
les entrées des deux fichiers cachespec.xml sont
fusionnées. Si des entrées des deux fichiers sont conflictuelles, les entrées
du fichier
cachespec.xml se trouvant dans l'application
remplacent celles du fichier
cachespec.xml global de
cette application.
gotcha
L'élément <cache-entry> peut être imbriqué dans l'élément <cache> ou dans un élément <cache-instance>. Les éléments <cache-entry> qui sont imbriqués dans l'élément <cache> sont mis en cache dans l'instance par défaut de la mémoire cache. Tout élément <cache-entry> se trouvant dans l'élément <cache-instance> est mis en cache dans l'instance spécifiée dans l'attribut name de l'élément <cache-instance>.
Un élément <cache-entry> contient des paramètres qui permettent d'effectuer les tâches suivantes pour activer la mise en cache dynamique du fichier cachespec.xml :
Procédure
- Développez un fichier cachespec.xml.
- Créez un fichier de configuration de mise en cache.
Dans le répertoire <racine_serveur_app>/properties, recherchez le fichier cachespec.sample.xml.
- Copiez le fichier cachespec.sample.xml dans le fichier cachespec.xml du
répertoire du module Web WEB-INF ou du bean enterprise META-INF.
- Définissez les éléments d'entrée de cache (cache-entry) nécessaires à l'identification des objets pouvant être mise en cache. Pour obtenir la liste des éléments, voir la rubrique relative au fichier cachespec.xml.
- Développez des règles d'ID cache.
Pour mettre un objet en mémoire cache, WebSphere Application Server doit savoir comment générer des ID uniques pour les différents appels de cet objet.
Cette tâche est effectuée par l'élément <cache-id>.
Chaque entrée de cache peut comporter plusieurs règles d'ID cache qui s'exécutent dans l'ordre jusqu'à ce qu'une règle renvoie un ID cache ou qu'il ne reste aucune autre règle à exécuter. Si aucune règle de génération d'ID cache ne donne lieu à un ID cache valide, l'objet n'est pas mis en mémoire cache. Développez les ID cache selon l'une des deux méthodes suivantes :
- Utilisez l'élément <component> défini dans la règle de cache d'une entrée de cache (recommandé). Reportez-vous à la rubrique Fichier cachespec_xml
pour plus d'informations sur l'élément <component>.
- Ecrivez le code Java™ personnalisé permettant de générer l'ID à partir des
variables d'entrée et de l'état du système. Pour configurer l'entrée de cache afin d'utiliser le générateur d'ID, spécifiez votre IdGenerator dans le fichier XML à l'aide de la balise <idgenerator>, par exemple :
<cache-entry>
<class>servlet</class>
<name>/servlet/CommandProcessor</name>
<cache-id>
<idgenerator>com.mycompany.SampleIdGeneratorImpl</idgenerator>
<timeout>60</timeout>
</cache-id>
</cache-entry>
- Spécifiez les règles d'ID de dépendance. Utilisez des éléments ID de dépendance pour spécifier d'autres identificateurs de groupe de mémoires cache qui associent plusieurs entrées de cache au même identificateur de groupe.
L'ID de dépendance est généré au moyen de la concaténation de la chaîne de base d'ID de dépendance avec les valeurs renvoyées par ses éléments component. Si un composant requis renvoie une valeur NULL, la totalité de l'ID de dépendance n'est pas générée et n'est pas utilisée. Vous pouvez valider les ID de dépendance de façon explicite via l'API de cache dynamique ou utiliser un autre élément <invalidation> d'entrée de cache.
Plusieurs règles d'ID de dépendance peuvent exister par entrée de cache. Toutes les règles d'ID de dépendance sont exécutées séparément. Consultez le fichier cachespec.xml pour obtenir la liste des éléments <component>.
- Invalidez d'autres entrées de cache sous la forme d'un effet secondaire de ce lancement d'objet, le cas échéant. Vous pouvez définir des règles d'invalidation exactement de la même manière que les ID de dépendance. Toutefois, les ID générés par des règles d'invalidation permettent d'invalider les entrées de cache comportant ces mêmes ID de dépendance.
L'ID d'invalidation est généré au moyen de la concaténation de la chaîne de base d'ID d'invalidation avec les valeurs renvoyées par son élément component. Si un composant requis renvoie une valeur NULL, la totalité de l'ID d'invalidation n'est pas générée et aucune invalidation n'a lieu. Plusieurs règles d'invalidation peuvent exister par entrée de cache. Toutes les règles d'invalidation sont exécutées séparément.
- Vérifiez que les règles de cache fonctionnent correctement. Vous pouvez modifier les règles dans le fichier cachespec.xml lors de l'exécution de l'application. La mémoire cache dynamique recharge le fichier mis à jour automatiquement. Si vous mettez en cache du contenu statique et que vous ajoutez la règle de cache à une application pour la première fois, vous devez redémarrer l'application. Vous n'avez pas besoin de redémarrer le serveur d'applications pour activer la nouvelle règle de cache. Pour plus d'informations, reportez-vous à la rubrique
Vérification de la page pouvant être mise en cache.
Que faire ensuite
En général, vous déclarez plusieurs éléments
<cache-entry> dans un fichier
cachespec.xml.
Lorsque de nouvelles versions du fichier cachespec.xml sont détectées, les anciennes règles sont remplacées. Les
objets mis en cache via l'ancien fichier de règles ne sont pas
automatiquement invalidés à partir du cache ; ils sont réutilisés avec les nouvelles règles ou supprimés du cache via son algorithme de remplacement.
Pour chacun des trois ID (cache, dépendance, invalidation) généré par des entrées de cache, un élément <cache-entry> peut contenir plusieurs éléments. La mémoire cache dynamique exécute les règles <cache-id> dans l'ordre et le premier qui génère correctement un ID est utilisé pour mettre cette sortie en cache. Si l'objet doit être mis en cache, chacun des éléments <dependency-id> est exécuté pour générer un ensemble d'ID de dépendance pour cette entrée de cache. Finalement, chaque élément <invalidation> est exécuté afin de générer la liste des ID que la mémoire cache dynamique invalide, que cet objet soit mis en cache ou non.