Durch das Caching werden die Objekte, die das Programm oder das System häufig aufruft, im Speicher gespeichert und schnell aufgerufen werden, wenn sie einmal verwendet werden, ohne neue doppelte Instanzen zu erstellen. Dies kann die Systemaufwand verringern und die Systemeffizienz verbessern.
Caches können hauptsächlich in zwei Kategorien unterteilt werden:
1. Durch das Caching der Datei, wie der Name schon sagt, bezieht sich das Caching von Datei auf das Speichern von Daten auf der Festplatte, unabhängig davon, ob Sie sich im XML -Format, serialisierten Dateidat -Format oder anderen Dateiformaten befinden.
2. Speichercache implementieren Sie statische Karten in einer Klasse und führen Sie regelmäßige Ergänzungen, Löschen und Suchanfragen auf dieser Karte durch.
import Java.util.*; // Beschreibung: Cache verwalten // Erweiterbare Funktionen: Wenn Chche den Speicherüberlauf erreicht, müssen einige der frühesten Cache -Objekte gelöscht werden, für die die Erstellung der Erstellungszeit für jedes Cache -Objekt öffentliche Klasse CacheManager {private statische Hashmap Cachemap = New Hashmap (); // einzelne Instanzkonstruktor private cacheManager () {Super (); } // Boolean Cache public static boolean getImplEflag (String Key) {try {return (boolean) cachemap.get (key); } catch (nullPointerexception e) {return false; }} public static long getServerStartDt (String -Schlüssel) {try {return (long) cachemap.get (key); } catch (Ausnahme ex) {return 0; }} // Setzen Sie den Cache des booleschen öffentlichen synchronisierten statischen booleschen SetSimspleFlag (String -Schlüssel, boolean Flag) {if (Flag && getImplEflag (Key)) {// Wenn wahr, dürfe das Überschreiben nicht falsch zurückgegeben werden; } else {Cachemap.put (Schlüssel, Flag); zurückkehren; }} public synchronisierte statische boolean setSimpleFlag (String -Schlüssel, langer ServerbeGerGrundt) {if (cachemap.get (key) == null) {Cachemap.put (Schlüssel, ServerBegrundt); zurückkehren; } else {return false; }} // Cache abrufen. Synchronisierte statische Methode private synchronisierte statische Cache getCache (String -Schlüssel) {return (cache) cachemap.get (Schlüssel); } // Beurteilen Sie, ob ein Cache privat synchronisierte statische boolesche Hascache (String -Schlüssel) {return Cachemap.ContainsKey (Key); } // Alle Caches öffentlich synchronisierte statische void clearall () {cachemap.clear (); } // einen bestimmten Cache -Typ löschen und bestimmen, ob der Schlüssel und der eingehende Typ mit dem öffentlichen synchronisierten statischen Hohlraum clearall (String -Typ) übereinstimmen {Iterator i = cachemap.EntrySet (). Iterator (); String -Schlüssel; ArrayList arr = new ArrayList (); try {while (i.hasnext ()) {java.util.map.Entry Eintrag = (java.util.map.enterry) i.Next (); Key = (String) Eintrag.getKey (); if (key.startsWith (Typ)) {// if es übereinstimmt arr.add (key); }} für (int k = 0; k <arr.size (); k ++) {clearonly (arr.get (k)); }} catch (Ausnahme ex) {ex.printstacktrace (); }} // Löschen Sie den angegebenen Cache public synchronisierten statischen void klaren (String -Schlüssel) {Cachemap.remove (Schlüssel); } // Laden Sie den Cache öffentlich synchronisierten statischen Hohlraum -Putcache (String -Schlüssel, Cache OBJ) {Cachemap.put (Schlüssel, OBJ); } // Cache -Informationen öffentlich statischer Cache getCacheinfo (String -Schlüssel) {if (HasCache (Schlüssel)) {cache cache = getCache (Key); if (cacheexpired (cache)) {// rufen Sie auf, um festzustellen, ob die Methode cache.setExpired (true) terminiert werden soll; } return cache; } sonst return null; } // Cache -Informationen öffentlich statische void putcacheinfo (String -Schlüssel, Cache OBJ, Long DT, Boolean abgelaufen) {cache cache = new Cache (); Cache.setKey (Schlüssel); cache.settimeout (dt + system.currentTimemillis ()); // Legen Sie fest, wie lange der cache cache.setValue (OBJ) aktualisiert wird. cache.setExpired (abgelaufen); // Wenn der Cache standardmäßig geladen wird, ist der Beendigungsstatus falsch cachemap.put (Schlüssel, Cache); } // Schreiben Sie die Informationsmethode des Cache -Cache -Verfahrens um. Cache.setKey (Schlüssel); cache.settimeout (dt+system.currentTimemillis ()); Cache.setValue (OBJ); cache.setExpired (false); Cachemap.put (Schlüssel, Cache); } // Beurteilen Sie, ob der Cache public static boolean Cacheexpired (Cache Cache) {if (null == cache) {// Der eingehende Cache existiert nicht zurück. } long nowdt = system.currentTimemillis (); // Die aktuelle Anzahl von Millisekunden im System long cachedt = cache.getimeout (); // Die Anzahl der abgelaufenen Millisekunden im Cache if (cachedt <= 0 || cachedt> nowdt) {// Wenn die Ablaufzeit kleiner oder gleich Null ist oder die Ablaufzeit größer als die aktuelle Zeit ist, ist es falsch zurückzutret. } else {// Die Ablaufzeit ist größer als die Ablaufzeit, dh abgelaufene Return True; }} // Erhalten Sie die Größe im Cache public static int getCacheSize () {return cachemap.size (); } // Die Größe des angegebenen Typs public static int getCacheSize (String -Typ) {int k = 0; Iterator i = Cachemap.EntrySet (). Iterator (); String -Schlüssel; try {while (i.hasnext ()) {java.util.map.Entry Eintrag = (java.util.map.enterry) i.Next (); Key = (String) Eintrag.getKey (); if (key.indexof (type)! = -1) {// wenn es übereinstimmt, löschen Sie K ++; }}} catch (Ausnahme ex) {ex.printstacktrace (); } return k; } // Alle Key-Value-Namen im Cache-Objekt public static ArrayList getCacheAllkey () {ArrayList a = new ArrayList () abrufen; Versuchen Sie {iterator i = cachemap.EntrySet (). iterator (); while (i.hasnext ()) {java.util.map.Entry -Eintrag = (java.util.map.entry) i.Next (); A.Add ((String) Eintrag.getKey ()); }} catch (Ausnahme ex) {} endlich {return a; }} // Erhalten Sie den Schlüsselwertnamen des angegebenen Typs im Cache -Objekt public static ArrayList getCachelistkey (String -Typ) {ArrayList a = new ArrayList (); String -Schlüssel; Versuchen Sie {iterator i = cachemap.EntrySet (). iterator (); while (i.hasnext ()) {java.util.map.Entry -Eintrag = (java.util.map.entry) i.Next (); Key = (String) Eintrag.getKey (); if (key.indexof (type)! = -1) {a.add (key); }}} catch (Ausnahme ex) {} endlich {return a; }}} Paket lHm.hcy.guge.frameset.cache; public class cache {privater String -Schlüssel; // Cache -ID private Objektwert; // Cache -Daten private lange Zeitout; // Zeit private boolean abgelaufen; // Beenden Sie den öffentlichen Cache () {Super () nicht; } public cache (String -Schlüssel, Objektwert, langfristig, boolean abgelaufen) {this.key = key; this.Value = Wert; this.timeout = timeout; this.expired = abgelaufen; } public String getKey () {return key; } public Long GetTimeout () {return timeout; } öffentliches Objekt getValue () {Rückgabewert; } public void setKey (String String) {Key = String; } public void setTimeout (long l) {timeout = l; } public void setValue (Objektobjekt) {value = Object; } public boolean isexpired () {return abgelaufen; } public void setExpired (boolean b) {abgelaufen = b; }} // Testklasse, Klasse test {public static void main (String [] args) {System.out.println (CACHEMANAGER.GetSimsplEflag ("alksD"); // CacheManager.putcache ("ABC", New Cache ()); // CacheManager.putcache ("def", New Cache ()); // CacheManager.putcache ("CCC", New Cache ()); // CacheManager.Clearonly (""); // cache c = neuer cache (); // für (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 ("Größe vor Löschen:"+cacheManager.getCacheSize ()); // CacheManager.getCacheAllkey (); // CacheManager.Clearall ("aaaa"); // system.out.println ("Größe nach Löschen:"+cacheManager.getCachesize ()); // CacheManager.getCacheAllkey (); }}Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.