-
paquete lhm.hcy.guge.frameset.cache;
importar java.util.*;
/**
* <p>Título:</p>
*
* <p>Descripción: Administrar caché</p>
* Azul profundo 2008-11-28 pensar
* Función extensible: cuando chche alcanza el desbordamiento de la memoria, algunos de los primeros objetos de caché deben borrarse, lo que requiere ahorrar el tiempo de creación de cada objeto de caché.
* <p>Copyright: Copyright (c) 2008</p>
*
* <p>Empresa: </p>
*
* @autor Azul profundo 2008-11-11
* @versión 1.0
*/
administrador de caché de clase pública {
HashMap estático privado cacheMap = nuevo HashMap();
//Método de construcción de instancia única
administrador de caché privado() {
súper();
}
//Obtener el caché de valores booleanos
getSimpleFlag booleano estático público (clave de cadena) {
intentar{
devolver (booleano) cacheMap.get(clave);
}catch(NullPointerException e){
devolver falso;
}
}
público estático largo getServerStartdt (clave de cadena) {
intentar {
return (Largo)cacheMap.get(clave);
} captura (Excepción ex) {
devolver 0;
}
}
//Establece el caché de valores booleanos
setSimpleFlag booleano estático sincronizado público (clave de cadena, indicador booleano) {
if (flag && getSimpleFlag(key)) {//Si es verdadero, no se permite sobrescribir
devolver falso;
}demás{
cacheMap.put(clave, bandera);
devolver verdadero;
}
}
setSimpleFlag booleano estático sincronizado público (clave de cadena, inicio largo del servidor) {
si (cacheMap.get(clave) == nulo) {
cacheMap.put(clave,servidorbegrundt);
devolver verdadero;
}demás{
devolver falso;
}
}
//Obtener el caché. Métodos estáticos sincronizados
Caché estático sincronizado privado getCache (clave de cadena) {
devolver (caché) cacheMap.get(clave);
}
//Determinar si hay un caché
hasCache booleano estático sincronizado privado (clave de cadena) {
devolver cacheMap.containsKey(clave);
}
//Borrar todos los cachés
público sincronizado estático vacío clearAll() {
cacheMap.clear();
}
// Borra un tipo específico de caché y determina si su CLAVE coincide con el TIPO entrante atravesando todos los objetos bajo HASHMAP
vacío estático sincronizado público clearAll (tipo de cadena) {
Iterador i = cacheMap.entrySet().iterator();
Clave de cadena;
ArrayList<String> arr = nuevo ArrayList<String>();
intentar {
mientras (i.hasNext()) {
java.util.Map.Entry entrada = (java.util.Map.Entry) i.next();
clave = (Cadena) entrada.getKey();
if (key.startsWith(type)) { //Si coincide, eliminar
arr.add(clave);
}
}
for (int k = 0; k < arr.size(); k++) {
clearOnly(arr.get(k));
}
} captura (Excepción ex) {
ex.printStackTrace();
}
}
//Borrar el caché especificado
vacío estático sincronizado público clearOnly (clave de cadena) {
cacheMap.remove(clave);
}
//Cargar caché
putCache vacío estático sincronizado público (clave de cadena, obj de caché) {
cacheMap.put(clave, obj);
}
//Obtener información de caché
Caché estático público getCacheInfo (clave de cadena) {
si (hasCache(clave)) {
Caché caché = getCache(clave);
if (cacheExpired(cache)) { //Llame al método para determinar si se debe terminar
cache.setExpired(verdadero);
}
devolver caché;
}demás
devolver nulo;
}
//Cargar información de caché
public static void putCacheInfo (clave de cadena, objeto de caché, dt largo, booleano caducado) {
Caché caché = nuevo caché();
cache.setKey(clave);
cache.setTimeOut(dt + System.currentTimeMillis()); //Establece cuánto tiempo lleva actualizar el caché.
caché.setValue(obj);
cache.setExpired(expired); //Cuando el caché se carga de forma predeterminada, el estado de terminación es FALSO
cacheMap.put(clave, caché);
}
//Reescribe el método de carga de información de caché
putCacheInfo vacío estático público (clave de cadena, obj de caché, dt largo) {
Caché caché = nuevo caché();
cache.setKey(clave);
cache.setTimeOut(dt+System.currentTimeMillis());
caché.setValue(obj);
cache.setExpired(falso);
cacheMap.put(clave,caché);
}
//Determinar si el caché ha terminado
caché booleano estático públicoExpired (caché de caché) {
if (null == cache) { //El caché entrante no existe
devolver falso;
}
long nowDt = System.currentTimeMillis(); //El número actual de milisegundos en el sistema.
long cacheDt = cache.getTimeOut(); //Milisegundos de caducidad en la caché
if (cacheDt <= 0||cacheDt>nowDt) { //Cuando el tiempo de vencimiento es menor o igual a cero, o cuando el tiempo de vencimiento es mayor que el tiempo actual, es FALSO
devolver falso;
} else { //Expira si es mayor que el tiempo de vencimiento
devolver verdadero;
}
}
//Obtener el tamaño en caché
público estático int getCacheSize() {
devolver cacheMap.size();
}
//Obtener el tamaño del tipo especificado
público estático int getCacheSize (tipo de cadena) {
int k = 0;
Iterador i = cacheMap.entrySet().iterator();
Clave de cadena;
intentar {
mientras (i.hasNext()) {
java.util.Map.Entry entrada = (java.util.Map.Entry) i.next();
clave = (Cadena) entrada.getKey();
if (key.indexOf(type) != -1) { //Si coincide, elimínelo
k++;
}
}
} captura (Excepción ex) {
ex.printStackTrace();
}
devolver k;
}
//Obtener todos los nombres de valores clave en el objeto de caché
pública estática ArrayList<String> getCacheAllkey() {
ArrayList a = nueva ArrayList();
intentar {
Iterador i = cacheMap.entrySet().iterator();
mientras (i.hasNext()) {
java.util.Map.Entry entrada = (java.util.Map.Entry) i.next();
a.add((String) entrada.getKey());
}
} captura (Excepción ex) {} finalmente {
devolver un;
}
}
//Obtener el nombre del valor clave del tipo especificado en el objeto de caché
ArrayList público estático <String> getCacheListkey (tipo de cadena) {
ArrayList a = nueva ArrayList();
Clave de cadena;
intentar {
Iterador i = cacheMap.entrySet().iterator();
mientras (i.hasNext()) {
java.util.Map.Entry entrada = (java.util.Map.Entry) i.next();
clave = (Cadena) entrada.getKey();
si (key.indexOf(tipo)! = -1) {
a.add(clave);
}
}
} captura (Excepción ex) {} finalmente {
devolver un;
}
}
}
paquete lhm.hcy.guge.frameset.cache;
/**
* <p>Título:</p>
*
* <p>Descripción: Caché DTO</p>
*
* <p>Copyright: Copyright (c) 2008</p>
*
* <p>Empresa: </p>
*
* @autor Azul profundo 2008-11-11
* @versión 1.0
*/
caché de clase pública {
clave de cadena privada; // ID de caché
valor del objeto privado // datos de caché
privado largo tiempo de espera;//hora de actualización
booleano privado caducado //si terminar
caché pública() {
súper();
}
caché pública (clave de cadena, valor del objeto, tiempo de espera prolongado, booleano caducado) {
esta.clave = clave;
this.value = valor;
this.timeOut = tiempo de espera;
this.expired = caducado;
}
cadena pública getKey() {
tecla de retorno;
}
público largo getTimeOut() {
tiempo de espera de retorno;
}
objeto público getValue() {
valor de retorno;
}
setKey público vacío (cadena de cadena) {
clave = cadena;
}
setTimeOut vacío público (l largo) {
tiempo de espera = l;
}
setValue público vacío (objeto objeto) {
valor = objeto;
}
público booleano está caducado() {
devolución vencida;
}
setExpired público vacío (booleano b) {
caducado = b;
}
}
//Clase de prueba,
prueba de clase {
público estático vacío principal (String [] argumentos) {
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 = nuevo Caché();
// para (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("Tamaño antes de eliminar: "+CacheManager.getCacheSize());
// CacheManager.getCacheAllkey();
// CacheManager.clearAll("aaaa");
// System.out.println("Tamaño después de la eliminación: "+CacheManager.getCacheSize());
// CacheManager.getCacheAllkey();
}
}
Este artículo proviene del blog de CSDN. Indique la fuente al reimprimir: http://blog.csdn.net/hello_zhenyu/archive/2009/12/18/5030366.aspx.