English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
CacheDas bedeutet, dass Objekte, die das Programm oder das System häufig aufruft, im Speicher gespeichert werden, damit sie bei Bedarf schnell aufgerufen werden können, ohne dass neue doppelte Instanzen erstellt werden müssen. Dies kann den Systemverbrauch reduzieren und die Systemeffizienz erhöhen.
Der Cache kann in zwei Hauptkategorien unterteilt werden:
Ein, Datei-Cache, wie der Name schon sagt, bedeutet Datei-Cache, Daten auf der Festplatte zu speichern, egal ob es sich um XML-Format, Serialisierungsdatei DAT-Format oder andere Dateiformate handelt;
Zwei, Speicher-Cache, das ist, eine statische Map in einer Klasse zu implementieren, und diese Map regelmäßig hinzuzufügen, zu löschen und zu suchen.
import java.util.*;
//Beschreibung: Cache-Verwaltung
//Erweiterbare Funktionen: Wenn der Cache aus dem Speicher läuft, müssen einige der frühesten Cache-Objekte gelöscht werden, was eine Aufzeichnung der Erstellungszeit jedes Cache-Objekts erfordert
public class CacheManager {
private static HashMap cacheMap = new HashMap();
//Einzelnes Beispielkonstruktor
private CacheManager() {
super();
}
//Bekommen eines Boolean-Wertes aus dem Cache
public static boolean getSimpleFlag(String key) {
try {
return (Boolean) cacheMap.get(key);
}
return false;
}
}
public static long getServerStartdt(String key) {
try {
return (Long)cacheMap.get(key);
} catch (Exception ex) {
return 0;
}
}
//Setzen eines Boolean-Wertes im Cache
public synchronized static boolean setSimpleFlag(String key, boolean flag) {
if (flag && getSimpleFlag(key)) {//Wenn wahr, wird es nicht überschrieben
return false;
} else {
cacheMap.put(key, flag);
return true;
}
}
public synchronized static boolean setSimpleFlag(String key, long serverbegrundt) {
if (cacheMap.get(key) == null) {
cacheMap.put(key, serverbegrundt);
return true;
} else {
return false;
}
}
//Bekommen eines Caches. Synchronisierte statische Methode
private synchronized static Cache getCache(String key) {
return (Cache) cacheMap.get(key);
}
//Prüfen, ob ein Cache existiert
private synchronized static boolean hasCache(String key) {
return cacheMap.containsKey(key);
}
//Löschen aller Caches
public synchronized static void clearAll() {
cacheMap.clear();
}
//Löschen eines bestimmten Typs von Caches durch das Durchsuchen aller Objekte im HASHMAP, um zu prüfen, ob der KEY mit dem übergebenen TYPE übereinstimmt
public synchronized static void clearAll(String type) {
Iterator i = cacheMap.entrySet().iterator();
String key;
ArrayList arr = new ArrayList()
try {
while (i.hasNext()) {
java.util.Map.Entry entry = (java.util.Map.Entry) i.next();
key = (String) entry.getKey();
if (key.startsWith(type)) { //如果匹配则删除掉
arr.add(key);
}
}
for (int k = 0; k < arr.size(); k++) {
clearOnly(arr.get(k));
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
//清除指定的缓存
public synchronized static void clearOnly(String key) {
cacheMap.remove(key);
}
//载入缓存
public synchronized static void putCache(String key, Cache obj) {
cacheMap.put(key, obj);
}
//获取缓存信息
public static Cache getCacheInfo(String key) {
if (hasCache(key)) {
Cache cache = getCache(key);
if (cacheExpired(cache)) { //调用判断是否终止方法
cache.setExpired(true);
}
return cache;
} else
return null;
}
//载入缓存信息
public static void putCacheInfo(String key, Cache obj, long dt, boolean expired) {
Cache cache = new Cache();
cache.setKey(key);
cache.setTimeOut(dt + System.currentTimeMillis()); //设置多久后更新缓存
cache.setValue(obj);
cache.setExpired(expired); //缓存默认载入时，终止状态为FALSE
cacheMap.put(key, cache);
}
//重写载入缓存信息方法
public static void putCacheInfo(String key, Cache obj, long dt){
Cache cache = new Cache();
cache.setKey(key);
cache.setTimeOut(dt+System.currentTimeMillis());
cache.setValue(obj);
cache.setExpired(false);
cacheMap.put(key, cache);
}
//判断缓存是否终止
public static boolean cacheExpired(Cache cache) {
if (null == cache) { //传入的缓存不存在
return false;
}
long nowDt = System.currentTimeMillis(); //系统当前的毫秒数
long cacheDt = cache.getTimeOut(); //缓存内的过期毫秒数
if (cacheDt <= 0 || cacheDt > nowDt) { //过期时间小于等于零时，或者过期时间大于当前时间时，则为FALSE
return false;
} else { //大于过期时间 即过期
return true;
}
}
//获取缓存中的大小
public static int getCacheSize() {
return cacheMap.size();
}
//获取指定的类型的大小
public static int getCacheSize(String type) {
int k = 0;
Iterator i = cacheMap.entrySet().iterator();
String key;
try {
while (i.hasNext()) {
java.util.Map.Entry entry = (java.util.Map.Entry) i.next();
key = (String) entry.getKey();
if (key.indexOf(type) != -1) { //如果匹配则删除掉
k++;
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
return k;
}
//获取缓存对象中的所有键值名称
public static ArrayList getCacheAllkey() {
ArrayList a = new ArrayList();
try {
Iterator i = cacheMap.entrySet().iterator();
while (i.hasNext()) {
java.util.Map.Entry entry = (java.util.Map.Entry) i.next();
a.add((String) entry.getKey());
}
catch (Exception ex) {} finally {
return a;
}
}
//获取缓存对象中指定类型的键值名称
public static ArrayList getCacheListkey(String type) {
ArrayList a = new ArrayList();
String key;
try {
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 (Exception ex) {} finally {
return a;
}
}
}
package lhm.hcy.guge.frameset.cache;
public class Cache {
private String key;//缓存ID
private Object value;//缓存数据
private long timeOut;//更新时间
private boolean expired; //是否终止
public Cache() {
super();
}
public Cache(String key, Object value, long timeOut, boolean expired) {
this.key = key;
this.value = value;
this.timeOut = timeOut;
this.expired = expired;
}
public String getKey() {
return key;
}
public long getTimeOut() {
return timeOut;
}
public Object getValue() {
return value;
}
public void setKey(String string) {
key = string;
}
public void setTimeOut(long l) {
timeOut = l;
}
public void setValue(Object object) {
value = object;
}
public boolean isExpired() {
return expired;
}
public void setExpired(boolean b) {
expired = b;
}
}
//测试类，
class Test {
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("Vor dem Löschen der Größe:");+CacheManager.getCacheSize());
// CacheManager.getCacheAllkey();
// CacheManager.clearAll("aaaa");
// System.out.println("Nach dem Löschen der Größe:");+CacheManager.getCacheSize());
// CacheManager.getCacheAllkey();
}
}
Das ist der gesamte Inhalt dieses Artikels. Ich hoffe, er hilft Ihnen bei Ihrem Lernen und ich hoffe, dass alle viele Unterstützung für das Anschrei-Tutorial geben.
Erklärung: Der Inhalt dieses Artikels wurde aus dem Internet übernommen und gehört dem Urheberrechtsinhaber. Der Inhalt wurde von Internetbenutzern freiwillig beigesteuert und hochgeladen. Diese Website besitzt keine Eigentumsrechte und hat den Inhalt nicht von Hand bearbeitet. Sie übernimmt auch keine rechtlichen Verantwortlichkeiten. Wenn Sie urheberrechtlich geschützte Inhalte entdecken, sind Sie herzlich eingeladen, eine E-Mail an notice#w zu senden.3codebox.com (bei der Übermittlung von E-Mails, bitte # durch @ ersetzen) meldet, und stellt relevante Beweise zur Verfügung. Sobald nachgewiesen wird, dass Inhalte urheberrechtlich geschützt sind, wird diese Website die betreffenden urheberrechtlich geschützten Inhalte sofort löschen.