La mise en cache signifie que les objets que le programme ou le système appelle souvent sont stockés en mémoire et peuvent être appelés rapidement lorsqu'ils sont utilisés une fois, sans créer de nouvelles instances en double. Cela peut réduire les frais généraux du système et améliorer l'efficacité du système.
Les caches peuvent être principalement divisées en deux catégories:
1. Grâce à la mise en cache des fichiers, comme le nom l'indique, la mise en cache de fichier fait référence au stockage des données sur le disque, que vous soyez au format XML, au format de fichier sérialisé ou à d'autres formats de fichiers;
2. Cache de mémoire, c'est-à-dire implémenter des cartes statiques dans une classe et effectuer des ajouts réguliers, la suppression et la recherche de cette carte.
import java.util. *; // Description: Gérer le cache // Fonctions extensibles: Lorsque CHCHE atteint le débordement de la mémoire, certains des premiers objets de cache doivent être effacés, ce qui nécessite du temps de création pour chaque classe de cache Cache CacheManager {private static hashmap cachemap = new HashMap (); // Constructeur d'instance unique Private CacheManager () {super (); } // Get Boolean Cache public static boolean getSimpleflag (String key) {try {return (boolean) cachemap.get (key); } catch (nullpointerException e) {return false; }} public static long getServerStartdt (string key) {try {return (long) cachemap.get (key); } catch (exception ex) {return 0; }} // Définir le cache booléen public public synchronisé booléen statique setSimpleflag (key string, booléen flag) {if (flag && getsImpleflag (key)) {// si true, l'écrasement n'est pas autorisé à être renvoyé faux; } else {cachemap.put (key, drapeau); Retour Vrai; }} public synchronisé statique booléen setSimpleflag (key string, long serverBegrundt) {if (cachemap.get (key) == null) {cachemap.put (key, serverBegrundt); Retour Vrai; } else {return false; }} // Obtenez du cache. Méthode statique synchronisée privée Cache statique synchronisée getCache (String Key) {return (cache) cachemap.get (key); } // juger s'il y a un cache privé synchronisé statique booléen hascache (key string) {return cachemap.containsKey (key); } // Effacer tous les caches publiques Synchronisés statique void clearall () {cachemap.clear (); } // Effacer un certain type de cache et déterminer si sa clé et le type entrant correspondent au clearall void statique synchronisé public (type de chaîne) {iterator i = cachemap.entryset (). Iterator (); Clé de chaîne; ArrayList arr = new ArrayList (); try {while (i.hasnext ()) {java.util.map.entry entrée = (java.util.map.entry) i.next (); key = (string) entry.getKey (); if (key.startswith (type)) {// Si il correspond, supprimez arr.add (key); }} pour (int k = 0; k <arr.size (); k ++) {clearOnly (arr.get (k)); }} catch (exception ex) {ex.printStackTrace (); }} // Effacer le cache spécifié public synchronisé statique void ClearOnly (string key) {cachemap.reMove (key); } // Chargez le cache public synchronisé statique void putCache (clé de chaîne, cache obj) {cachemap.put (key, obj); } // obtenir des informations de cache public static cache getCacheInfo (string key) {if (hascache (key)) {cache cache = getCache (key); if (cacheexpired (cache)) {// Appelez pour déterminer s'il faut terminer la méthode cache.setExpired (true); } return cache; } else return null; } // Chargement des informations sur le cache public static void putCacheInfo (clé de chaîne, cache obj, long dt, boolean expired) {cache cache = new cache (); cache.setKey (key); cache.setTimeout (dt + system.currentTimemillis ()); // Définissez combien de temps pour mettre à jour le cache cache.setValue (OBJ); cache.setExpired (expiré); // Lorsque le cache est chargé par défaut, l'état de terminaison est false cachemap.put (clé, cache); } // Réécriture de la méthode d'information du cache de chargement public static void putCacheInfo (clé de chaîne, cache obj, long dt) {cache cache = new cache (); cache.setKey (key); cache.setTimeout (dt + system.currentTimemillis ()); cache.setValue (obj); cache.setExpired (false); cachemap.put (clé, cache); } // juger si le cache met fin public à booléen statique cacheexpired (cache cache) {if (null == cache) {// Le cache entrant n'existe pas de retour false; } long nowdt = System.currenttimemillis (); // le nombre actuel de millisecondes dans le système long cachedt = cache.getTimeout (); // Le nombre de millisecondes expirées dans le cache if (cachedt <= 0 || cachedt> nowdt) {// lorsque le temps d'expiration est inférieur ou égal à zéro, ou que le temps d'expiration est supérieur à l'heure actuelle, c'est un faux rendement faux; } else {// Le temps d'expiration est supérieur au temps d'expiration, c'est-à-dire, expiré return true; }} // Obtenez la taille du cache publique statique int getCachesize () {return cachemap.size (); } // Obtenez la taille du type spécifié public static int getCachesize (type de chaîne) {int k = 0; Iterator i = cachemap.entryset (). Iterator (); Clé de chaîne; try {while (i.hasnext ()) {java.util.map.entry entrée = (java.util.map.entry) i.next (); key = (string) entry.getKey (); if (key.indexof (type)! = -1) {// Si il correspond, supprimez k ++; }}} catch (exception ex) {ex.printStackTrace (); } return k; } // Obtenez tous les noms de valeur clé dans l'objet Cache public static arrayList getCacheallkey () {ArrayList a = new ArrayList (); essayez {iterator i = cachemap.entryset (). iterator (); while (i.hasnext ()) {java.util.map.entry entrée = (java.util.map.entry) i.next (); A.Add ((String) entry.getKey ()); }} catch (exception ex) {} enfin {return a; }} // Obtenez le nom de valeur de clé du type spécifié dans l'objet cache public static arrayList getCachelistKey (string type) {ArrayList a = new ArrayList (); Clé de chaîne; essayez {iterator i = cachemap.entryset (). iterator (); while (i.hasnext ()) {java.util.map.entry entrée = (java.util.map.entry) i.next (); key = (string) entry.getKey (); if (key.indexof (type)! = -1) {a.add (key); }}} catch (exception ex) {} enfin {return a; }}} package lhm.hcy.guge.frameset.cache; classe publique Cache {clé de chaîne privée; // ID de cache Valeur d'objet privé; // Données de cache Tempsue privé long; // Mettez à jour le temps privé booléen expiré; // ne terminez pas public cache () {super (); } cache public (clé de chaîne, valeur d'objet, temps de temps long, booléen expiré) {this.key = key; this.value = valeur; this.timeout = timeout; this.expired = expiré; } public String getKey () {return key; } public long getTimeout () {return timeout; } Objet public getValue () {return Value; } public void setKey (string string) {key = string; } public void setTimeout (long l) {timeout = l; } public void setValue (objet objet) {value = objet; } public boolean isexpired () {return expire; } public void setExpired (boolean b) {expired = b; }} // Classe de test, classe Test {public static void main (String [] args) {System.out.println (cacheManager.getSimpleflag ("alksd")); // cacheManager.putCache ("ABC", new Cache ()); // cacheManager.putCache ("def", new cache ()); // cacheManager.putCache ("ccc", new cache ()); // cacheManager.Clearonly (""); // cache c = new cache (); // pour (int i = 0; i <10; i ++) {// cacheManager.putCache ("" + i, c); //} // cacheManager.putCache ("aaaaaaaa", c); // cacheManager.putCache ("Abchcy; alskd", c); // cacheManager.putCache ("CCCCCCCC", C); // cacheManager.putCache ("abcoqiwhcy", c); // System.out.println ("Taille avant la suppression:" + cacheManager.getCacheSize ()); // cacheManager.getCacheallkey (); // cachemanager.clearall ("aaaa"); // System.out.println ("Taille après suppression:" + cacheManager.getCacheSize ()); // cacheManager.getCacheallkey (); }}Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.