-
pacote lhm.hcy.guge.frameset.cache;
importar java.util.*;
/**
* <p>Título: </p>
*
* <p>Descrição: Gerenciar cache</p>
* Azul profundo 28/11/2008 pense
* Função extensível: Quando o chche atinge o estouro de memória, alguns dos primeiros objetos de cache devem ser limpos, o que requer salvar o tempo de criação de cada objeto de cache.
* <p>Direitos autorais: Direitos autorais (c) 2008</p>
*
* <p>Empresa:</p>
*
* @autor Deepblue 11/11/2008
*@versão 1.0
*/
classe pública CacheManager {
hashMap estático privado cacheMap = new HashMap();
//Método de construção de instância única
private CacheManager() {
super();
}
//Obtém o cache de valores booleanos
public static boolean getSimpleFlag(String key){
tentar{
return (Booleano) cacheMap.get(chave);
}catch(NullPointerException e){
retornar falso;
}
}
public static long getServerStartdt(String key){
tentar {
return (longo)cacheMap.get(chave);
} catch (Exceção ex) {
retornar 0;
}
}
//Define o cache de valores booleanos
público sincronizado estático booleano setSimpleFlag(String key,boolean flag){
if (flag && getSimpleFlag(key)) {//Se verdadeiro, a substituição não é permitida
retornar falso;
}outro{
cacheMap.put(chave, sinalizador);
retornar verdadeiro;
}
}
público sincronizado estático booleano setSimpleFlag(String key,long serverbegrundt){
if (cacheMap.get (chave) == nulo) {
cacheMap.put(chave,serverbegrundt);
retornar verdadeiro;
}outro{
retornar falso;
}
}
//Obter o cache. Métodos estáticos sincronizados
Cache estático sincronizado privado getCache(String key) {
return (Cache) cacheMap.get(chave);
}
//Determina se existe um cache
hasCache booleano estático sincronizado privado (chave String) {
retornar cacheMap.containsKey(chave);
}
//Limpa todos os caches
público sincronizado estático void clearAll() {
cacheMap.clear();
}
//Limpa um tipo específico de cache e determina se sua KEY corresponde ao TYPE recebido, percorrendo todos os objetos no HASHMAP
público sincronizado estático void clearAll(tipo String) {
Iterador i = cacheMap.entrySet().iterator();
Chave de string;
ArrayList<String> arr = new ArrayList<String>();
tentar {
enquanto (i.hasNext()) {
entrada java.util.Map.Entry = (java.util.Map.Entry) i.next();
chave = (String) entrada.getKey();
if (key.startsWith(type)) { //Se corresponder, exclua
arr.add(chave);
}
}
for (int k = 0; k < arr.size(); k++) {
clearOnly(arr.get(k));
}
} catch (Exceção ex) {
ex.printStackTrace();
}
}
//Limpa o cache especificado
público sincronizado estático void clearOnly (chave String) {
cacheMap.remove(chave);
}
//Carrega cache
público sincronizado estático void putCache(String key, Cache obj) {
cacheMap.put(chave,obj);
}
//Obter informações do cache
Cache estático público getCacheInfo (chave de string) {
if (hasCache(chave)) {
Cache cache = getCache(chave);
if (cacheExpired(cache)) { //Chama o método para determinar se deseja encerrar
cache.setExpired(true);
}
cache de retorno;
}outro
retornar nulo;
}
//Carrega informações do cache
public static void putCacheInfo(String key, Cache obj, long dt,boolean expired) {
Cache cache = new Cache();
cache.setKey(chave);
cache.setTimeOut(dt + System.currentTimeMillis()); //Definir quanto tempo leva para atualizar o cache
cache.setValue(obj);
cache.setExpired(expired); //Quando o cache é carregado por padrão, o status de encerramento é FALSE
cacheMap.put(chave,cache);
}
//Reescreva o método de carregamento de informações de cache
public static void putCacheInfo(String key,Cache obj,long dt){
Cache cache = new Cache();
cache.setKey(chave);
cache.setTimeOut(dt+System.currentTimeMillis());
cache.setValue(obj);
cache.setExpired(falso);
cacheMap.put(chave,cache);
}
//Determina se o cache foi encerrado
public static boolean cacheExpired (cache de cache) {
if (null == cache) { //O cache de entrada não existe
retornar falso;
}
long nowDt = System.currentTimeMillis(); //O número atual de milissegundos no sistema
long cacheDt = cache.getTimeOut(); //Expiração em milissegundos no cache
if (cacheDt <= 0||cacheDt>nowDt) { //Quando o tempo de expiração for menor ou igual a zero, ou quando o tempo de expiração for maior que o horário atual, é FALSO
retornar falso;
} else { //Expira se for maior que o tempo de expiração
retornar verdadeiro;
}
}
//Obtém o tamanho no cache
public static int getCacheSize() {
retornar cacheMap.size();
}
//Obtém o tamanho do tipo especificado
public static int getCacheSize(tipo String) {
int k = 0;
Iterador i = cacheMap.entrySet().iterator();
Chave de string;
tentar {
enquanto (i.hasNext()) {
entrada java.util.Map.Entry = (java.util.Map.Entry) i.next();
chave = (String) entrada.getKey();
if (key.indexOf(type) != -1) { //Se corresponder, exclua-o
k++;
}
}
} catch (Exceção ex) {
ex.printStackTrace();
}
retornar k;
}
//Obtém todos os nomes de valores-chave no objeto de cache
public static ArrayList<String> getCacheAllkey() {
ArrayList a = new ArrayList();
tentar {
Iterador i = cacheMap.entrySet().iterator();
enquanto (i.hasNext()) {
entrada java.util.Map.Entry = (java.util.Map.Entry) i.next();
a.add((String)entrada.getKey());
}
} catch (Exceção ex) {} finalmente {
retornar um;
}
}
//Obtém o nome do valor-chave do tipo especificado no objeto de cache
public static ArrayList<String> getCacheListkey(Tipo String) {
ArrayList a = new ArrayList();
Chave de string;
tentar {
Iterador i = cacheMap.entrySet().iterator();
enquanto (i.hasNext()) {
entrada java.util.Map.Entry = (java.util.Map.Entry) i.next();
chave = (String) entrada.getKey();
if (key.indexOf(tipo) != -1) {
a.add(chave);
}
}
} catch (Exceção ex) {} finalmente {
retornar um;
}
}
}
pacote lhm.hcy.guge.frameset.cache;
/**
* <p>Título: </p>
*
* <p>Descrição: Cache DTO</p>
*
* <p>Direitos autorais: Direitos autorais (c) 2008</p>
*
* <p>Empresa:</p>
*
* @autor Deepblue 11/11/2008
*@versão 1.0
*/
Cache de classe pública {
chave de string privada; //ID do cache
valor do objeto privado // dados em cache
private long timeOut; //tempo de atualização
private boolean expirou; //se deseja encerrar
Cache público() {
super();
}
Cache público (chave de string, valor do objeto, tempo limite longo, booleano expirado) {
esta.chave = chave;
este.valor = valor;
this.timeOut = tempo limite;
this.expired = expirou;
}
string pública getKey() {
chave de retorno;
}
público longo getTimeOut() {
retornar tempo limite;
}
objeto público getValor() {
valor de retorno;
}
public void setKey(String string) {
chave=sequência;
}
public void setTimeOut(longo l) {
tempo limite = l;
}
public void setValue(objeto objeto) {
valor = objeto;
}
public boolean isExpired() {
retorno expirou;
}
public void setExpired(boolean b) {
expirado = b;
}
}
//Classe de teste,
teste de classe {
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();
//for (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("Tamanho antes da exclusão: "+CacheManager.getCacheSize());
//CacheManager.getCacheAllkey();
//CacheManager.clearAll("aaaa");
// System.out.println("Tamanho após exclusão: "+CacheManager.getCacheSize());
//CacheManager.getCacheAllkey();
}
}
Este artigo vem do blog CSDN. Por favor, indique a fonte ao reimprimir: http://blog.csdn.net/hello_zhenyu/archive/2009/12/18/5030366.aspx.