El almacenamiento en caché significa que los objetos que el programa o el sistema a menudo llama se almacenan en la memoria, y se pueden llamar rápidamente cuando se usa una vez, sin crear nuevas instancias duplicadas. Hacerlo puede reducir la sobrecarga del sistema y mejorar la eficiencia del sistema.
Los cachés se pueden dividir principalmente en dos categorías:
1. A través del almacenamiento en caché de archivos, como lo indica el nombre, el almacenamiento en caché de archivos se refiere al almacenamiento de datos en el disco, ya sea que esté en formato XML, formato dat de archivo serializado u otros formatos de archivo;
2. Memory Cache, es decir, implementar mapas estáticos en una clase y realizar adiciones, eliminación y búsquedas regulares en este mapa.
import java.util.*; // Descripción: Administrar caché // Funciones extensibles: Cuando el chche alcanza el desbordamiento de la memoria, se deben borrar algunos de los objetos de caché más tempranos, lo que requiere ahorrar tiempo de creación para cada objeto de caché Cachemanager Cachemanager {PRIVED STARICHMAP CACHEMAP = New HashMap (); // Constructor de instancia única Cachemanager () {super (); } // Obtener caché booleano público estático booleano booleano GetSimpleFlag (clave de cadena) {try {return (boolean) Cachemap.get (clave); } catch (nullPointerException e) {return false; }} public static long getServerStartdt (tecla de cadena) {try {return (long) cachemap.get (clave); } catch (excepción ex) {return 0; }} // Establecer caché booleano público sincronizado setsimpleflag (clave de cadena, bandera booleana) {if (flag && getSimpleFlag (key)) {// Si es verdadero, no se permite que la sobrescribencia se devuelva falso; } else {Cachemap.put (clave, bandera); devolver verdadero; }} public sincronizado setSimpleFlag (Key de cadena, Long ServerBegrundt) {if (Cachemap.get (Key) == NULL) {Cachemap.put (Key, ServerBegrundt); devolver verdadero; } else {return false; }} // Get Cache. Método estático sincronizado El caché estático sincronizado privado getCache (tecla de cadena) {return (caché) cachemap.get (clave); } // juzga si hay un cache privado sincronizado static boolean hascache (tecla de cadena) {return cachemap.containskey (clave); } // Borrar todos los cachés público sincronizado vacío estático ClearAll () {Cachemap.Clear (); } // Borrar un cierto tipo de caché y determinar si su clave y el tipo entrante coinciden con el público sincronizado público sincronizado ClearAll (tipo de cadena) {Iterator i = Cachemap.entryset (). Iterator (); Tecla de cadena; ArrayList arr = new ArrayList (); Pruebe {while (i.hasnext ()) {java.util.map.entry entry = (java.util.map.entry) I.Next (); Key = (String) Entry.getKey (); if (key.startswith (type)) {// Si coincide, elimina arr.add (key); }} para (int k = 0; k <arr.size (); k ++) {clearOnly (arr.get (k)); }} capt (excepción ex) {ex.printstackTrace (); }} // Borrar el público de caché especificado sincronizado void static clearOnly (tecla de cadena) {cachemap.remove (clave); } // Cargue el void static sincronizado público de caché Putcache (tecla de cadena, caché obj) {cachemap.put (key, obj); } // Obtener información de caché public static cache getCacheinfo (tecla de cadena) {if (hasCache (key)) {caché cache = getCache (key); if (cacheExPired (cache)) {// llama para determinar si finaliza el método cache.setEppired (true); } return cache; } else return null; } // Cargar información de caché Public static void PutCacheinfo (clave de cadena, caché obj, dt largo, boolean expirado) {caché cache = new cache (); cache.setkey (clave); Cache.setTimeOut (DT + System.CurrentTimemillis ()); // establece cuánto tiempo actualizar el caché cache.setValue (obj); cache.setEppled (expirado); // Cuando el caché se carga de forma predeterminada, el estado de terminación es falso cachemap.put (clave, caché); } // Reescribe el método de información de carga de carga Public static void PutCacheinfo (clave de cadena, caché obj, long dt) {caché cache = new cache (); cache.setkey (clave); Cache.setTimeOut (DT+System.CurrentTimemillis ()); cache.setValue (obj); cache.setEpplired (falso); Cachemap.put (clave, caché); } // juzga si el caché termina public static static boolean cacheExpired (caché cache) {if (null == caché) {// El caché entrante no existe return false; } long Nowdt = System.CurrentTimemillis (); // El número actual de milisegundos en el sistema Long Cachedt = Cache.getTimeout (); // El número de milisegundos caducados en el caché if (Cachedt <= 0 || Cachedt> Nowdt) {// Cuando el tiempo de vencimiento es menor o igual a cero, o el tiempo de vencimiento es mayor que el tiempo actual, es falso retorno falso; } else {// El tiempo de vencimiento es mayor que el tiempo de vencimiento, es decir, el retorno vencido verdadero; }} // Obtenga el tamaño en la caché public static int getCachesize () {return Cachemap.size (); } // Obtenga el tamaño del tipo especificado public static int getCachesize (tipo de cadena) {int k = 0; Iterador i = Cachemap.entryset (). Iterator (); Tecla de cadena; Pruebe {while (i.hasnext ()) {java.util.map.entry entry = (java.util.map.entry) I.Next (); Key = (String) Entry.getKey (); if (key.indexof (type)! = -1) {// Si coincide, elimine k ++; }}} Catch (Exception Ex) {Ex.PrintStackTrace (); } return k; } // Obtenga todos los nombres de valor clave en el objeto de caché public static arrayList getCacheAllKey () {ArrayList a = new ArrayList (); intente {iterator i = cachemap.entryset (). iterator (); while (i.hasnext ()) {java.util.map.entry entry = (java.util.map.entry) I.Next (); A.Add ((String) Entry.getKey ()); }} capt (excepción ex) {} finalmente {return a; }} // Obtenga el nombre de valor clave del tipo especificado en el objeto Cache Public Static ArrayList getCachelistKey (tipo de cadena) {ArrayList a = new ArrayList (); Tecla de cadena; intente {iterator i = cachemap.entryset (). iterator (); while (i.hasnext ()) {java.util.map.entry entry = (java.util.map.entry) I.Next (); Key = (String) Entry.getKey (); if (key.indexof (type)! = -1) {a.add (key); }}} catch (excepción ex) {} finalmente {return a; }}} paquete lhm.hcy.guge.frameset.cache; public class Cache {Key de cadena privada; // Valor de objeto privado de ID de caché; // Datos de caché Tiempo de espera privado de larga duración; // Actualización de tiempo de actualización booleana privada expirada; // No termine public cache () {super (); } public cache (clave de cadena, valor de objeto, tiempo de espera largo, boolean expirado) {this.key = key; this.Value = value; this.timeout = Tiempo de espera; this.EppiRed = expirado; } public String getKey () {Key de retorno; } public Long GetTimeOut () {return timeOut; } Public Object getValue () {Valor de retorno; } public void setKey (string string) {key = string; } public void setTimeout (long l) {timeout = l; } public void setValue (objeto objeto) {valor = objeto; } public boolean isEpchired () {return expiró; } public void setExpered (boolean b) {expirado = b; }} // prueba de prueba, prueba de clase {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 (""); // caché c = new Cache (); // para (int i = 0; i <10; i ++) {// cachemanager.putcache (""+i, c); //} // Cachemanager.putCache ("aaaaaaaaa", c); // Cachemanager.putCache ("Abchcy; Alskd", c); // Cachemanager.putCache ("CCCCCCCC", c); // Cachemanager.putCache ("abcoqiwhcy", c); // System.out.println ("Tamaño antes de la eliminación:"+Cachemanager.getCachesize ()); // Cachemanager.getCacheAllKey (); // Cachemanager.ClearAll ("AAAA"); // System.out.println ("Tamaño después de la eliminación:"+Cachemanager.getCachesize ()); // Cachemanager.getCacheAllKey (); }}Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.