-
paquet lhm.hcy.guge.frameset.cache ;
importer java.util.* ;
/**
* <p>Titre : </p>
*
* <p>Description : Gérer le cache</p>
* Bleu profond 2008-11-28 je pense
* Fonction extensible : lorsque chche atteint un débordement de mémoire, certains des premiers objets de cache doivent être effacés, ce qui nécessite de sauvegarder le temps de création de chaque objet de cache.
* <p>Droits d'auteur : Copyright (c) 2008</p>
*
* <p>Entreprise : </p>
*
* @auteur Deepblue 2008-11-11
* @version 1.0
*/
classe publique CacheManager {
HashMap statique privé cacheMap = new HashMap();
//Méthode de construction à instance unique
CacheManager privé() {
super();
}
//Récupère le cache des valeurs booléennes
public statique booléen getSimpleFlag (clé de chaîne) {
essayer{
return (booléen) cacheMap.get(key);
}catch(NullPointerException e){
renvoie faux ;
}
}
public statique long getServerStartdt (clé de chaîne) {
essayer {
return (Long)cacheMap.get(clé);
} catch (Exception ex) {
renvoie 0 ;
}
}
//Définit le cache des valeurs booléennes
booléen statique synchronisé public setSimpleFlag (clé de chaîne, indicateur booléen) {
if (flag && getSimpleFlag(key)) {//Si vrai, l'écrasement n'est pas autorisé
renvoie faux ;
}autre{
cacheMap.put(clé, drapeau);
renvoie vrai ;
}
}
public synchronisé statique booléen setSimpleFlag (String key, long serverbegrundt) {
if (cacheMap.get(key) == null) {
cacheMap.put(key,serverbegrundt);
renvoie vrai ;
}autre{
renvoie faux ;
}
}
//Récupère le cache. Méthodes statiques synchronisées
Cache statique synchronisé privé getCache (clé de chaîne) {
return (Cache) cacheMap.get(clé);
}
//Détermine s'il existe un cache
booléen statique synchronisé privé hasCache (clé de chaîne) {
return cacheMap.containsKey(key);
}
//Effacer tous les caches
public synchronisé static void clearAll() {
cacheMap.clear();
}
//Effacer un type spécifique de cache et déterminer si sa CLÉ correspond au TYPE entrant en parcourant tous les objets sous le HASHMAP
public synchronisé static void clearAll (type de chaîne) {
Itérateur i = cacheMap.entrySet().iterator();
Clé de chaîne ;
ArrayList<String> arr = new ArrayList<String>();
essayer {
tandis que (i.hasNext()) {
entrée java.util.Map.Entry = (java.util.Map.Entry) i.next();
key = (String) Entry.getKey();
if (key.startsWith(type)) { //Si correspond, supprimer
arr.add(clé);
}
}
pour (int k = 0; k < arr.size(); k++) {
clearOnly(arr.get(k));
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
//Effacer le cache spécifié
public synchronisé static void clearOnly (String key) {
cacheMap.remove(clé);
}
//Charger le cache
public synchronisé static void putCache (String key, Cache obj) {
cacheMap.put(clé, obj);
}
//Obtenir les informations du cache
cache statique public getCacheInfo (clé de chaîne) {
si (hasCache(clé)) {
Cache cache = getCache(clé);
if (cacheExpired(cache)) { //Appelle la méthode pour déterminer s'il faut terminer
cache.setExpired(true);
}
retourner le cache ;
}autre
renvoie null ;
}
//Charger les informations du cache
public static void putCacheInfo (clé de chaîne, cache obj, long dt, booléen expiré) {
Cache cache = nouveau Cache();
cache.setKey(clé);
cache.setTimeOut(dt + System.currentTimeMillis()); //Définit le temps nécessaire pour mettre à jour le cache
cache.setValue(obj);
cache.setExpired(expired); //Lorsque le cache est chargé par défaut, l'état de terminaison est FALSE
cacheMap.put(clé, cache);
}
//Réécrire la méthode de chargement des informations du cache
public static void putCacheInfo (clé de chaîne, cache obj, long dt) {
Cache cache = nouveau Cache();
cache.setKey(clé);
cache.setTimeOut(dt+System.currentTimeMillis());
cache.setValue(obj);
cache.setExpired(false);
cacheMap.put(clé,cache);
}
//Détermine si le cache est terminé
public static boolean cacheExpired (Cache cache) {
if (null == cache) { //Le cache entrant n'existe pas
renvoie faux ;
}
long nowDt = System.currentTimeMillis(); //Le nombre actuel de millisecondes dans le système
long cacheDt = cache.getTimeOut(); //Millisecondes d'expiration dans le cache
if (cacheDt <= 0||cacheDt>nowDt) { //Lorsque le délai d'expiration est inférieur ou égal à zéro, ou lorsque le délai d'expiration est supérieur à l'heure actuelle, il est FAUX
renvoie faux ;
} else { //Expire s'il est supérieur au délai d'expiration
renvoie vrai ;
}
}
//Récupère la taille en cache
public statique int getCacheSize() {
return cacheMap.size();
}
//Obtenir la taille du type spécifié
public static int getCacheSize (type de chaîne) {
entier k = 0 ;
Itérateur i = cacheMap.entrySet().iterator();
Clé de chaîne ;
essayer {
tandis que (i.hasNext()) {
entrée java.util.Map.Entry = (java.util.Map.Entry) i.next();
key = (String) Entry.getKey();
if (key.indexOf(type) != -1) { //S'il correspond, supprimez-le
k++;
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
retourner k ;
}
//Obtenir tous les noms de valeurs clés dans l'objet cache
public static ArrayList<String> getCacheAllkey() {
ArrayList a = new ArrayList();
essayer {
Itérateur i = cacheMap.entrySet().iterator();
tandis que (i.hasNext()) {
entrée java.util.Map.Entry = (java.util.Map.Entry) i.next();
a.add((String) Entry.getKey());
}
} catch (Exception ex) {} enfin {
renvoyer un ;
}
}
//Obtenir le nom de la valeur clé du type spécifié dans l'objet cache
public static ArrayList<String> getCacheListkey (type de chaîne) {
ArrayList a = new ArrayList();
Clé de chaîne ;
essayer {
Itérateur i = cacheMap.entrySet().iterator();
tandis que (i.hasNext()) {
entrée java.util.Map.Entry = (java.util.Map.Entry) i.next();
key = (String) Entry.getKey();
if (key.indexOf(type) != -1) {
a.add(clé);
}
}
} catch (Exception ex) {} enfin {
renvoyer un ;
}
}
}
paquet lhm.hcy.guge.frameset.cache ;
/**
* <p>Titre : </p>
*
* <p>Description : Cache DTO</p>
*
* <p>Droits d'auteur : Copyright (c) 2008</p>
*
* <p>Entreprise : </p>
*
* @auteur Deepblue 2008-11-11
* @version 1.0
*/
Cache de classe publique {
clé de chaîne privée ; // ID de cache
valeur d'objet privé ; // données en cache
privé long timeOut ; // heure de mise à jour
private boolean expired ; //s'il faut terminer
Cache public() {
super();
}
cache public (clé de chaîne, valeur de l'objet, long timeOut, booléen expiré) {
this.key = clé ;
this.value = valeur ;
this.timeOut = timeOut;
this.expired = expiré ;
}
chaîne publique getKey() {
clé de retour ;
}
public long getTimeOut() {
retourner timeOut ;
}
Objet public getValue() {
valeur de retour ;
}
public void setKey (chaîne de caractères) {
clé = chaîne ;
}
public void setTimeOut (long l) {
timeOut = l;
}
public void setValue (objet objet) {
valeur = objet ;
}
public booléen isExpired() {
retour expiré ;
}
public void setExpired(booléen b) {
expiré = b;
}
}
//Classe de test,
classe Test {
public static void main (String[] arguments) {
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 = nouveau 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 suppression : "+CacheManager.getCacheSize());
// CacheManager.getCacheAllkey();
// CacheManager.clearAll("aaaa");
// System.out.println("Taille après suppression : "+CacheManager.getCacheSize());
// CacheManager.getCacheAllkey();
}
}
Cet article provient du blog CSDN Veuillez indiquer la source lors de la réimpression : http://blog.csdn.net/hello_zhenyu/archive/2009/12/18/5030366.aspx.