تحقيق ميكانيكية التخزين المؤقت Cache الشائعة في Java

التخزين المؤقتهذا يعني أن يتم تخزين الأشياء التي يستدعيها البرنامج أو النظام بشكل متكرر في الذاكرة، لذا يمكن التحقق منها بسرعة عند الاستدعاء، دون الحاجة إلى إنشاء نموذج جديد مكرر. يمكن بذلك تقليل تكاليف النظام وزيادة كفاءته.

يمكن تقسيم التخزين المؤقت بشكل رئيسي إلى فئتين:　　　

أولاً، التخزين المؤقت على ملف، بمعنى أن يتم تخزين البيانات على القرص الصلب، سواء كان ذلك بتنسيق XML أو ملفات DAT المشفر أو أي تنسيق ملف آخر؛　

ثانيًا، التخزين المؤقت في الذاكرة، أي تنفيذ فئة ديناميكية تحتوي على خريطة ثابتة، يتم إجراء عمليات إضافة وإزالة وتحديد لهذه الخريطة.

import java.util.*; 
 //Description: 管理缓存 
 //可扩展的功能：当chche到内存溢出时必须清除掉最早期的一些缓存对象，这就要求对每个缓存对象保存创建时间 
public class CacheManager { 
 private static HashMap cacheMap = new HashMap(); 
 //单实例构造方法 
 private CacheManager() { 
  super(); 
 } 
 //获取布尔值的缓存 
 public static boolean getSimpleFlag(String key){ 
  try{ 
   return (Boolean) cacheMap.get(key); 
  catch(NullPointerException e){ 
   return false; 
  } 
 } 
 public static long getServerStartdt(String key){ 
  try { 
   return (Long)cacheMap.get(key); 
  } catch (Exception ex) { 
   return 0; 
  } 
 } 
 //设置布尔值的缓存 
 public synchronized static boolean setSimpleFlag(String key, boolean flag) { 
  if (flag && getSimpleFlag(key)) { //假如为真不允许被覆盖 
   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; 
  } 
 } 
 //得到缓存。同步静态方法 
 private synchronized static Cache getCache(String key) { 
  return (Cache) cacheMap.get(key); 
 } 
 //判断是否存在一个缓存 
 private synchronized static boolean hasCache(String key) { 
  return cacheMap.containsKey(key); 
 } 
 //清除所有缓存 
 public synchronized static void clearAll() { 
  cacheMap.clear(); 
 } 
 //清除某一类特定缓存,通过遍历HASHMAP下的所有对象，来判断它的KEY与传入的TYPE是否匹配 
 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;//معرف المخزن 
  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("حجم قبل الحذف: " + CacheManager.getCacheSize()); 
//  CacheManager.getCacheAllkey(); 
//  CacheManager.clearAll("aaaa"); 
//  System.out.println("حجم بعد الحذف: " + CacheManager.getCacheSize()); 
//  CacheManager.getCacheAllkey(); 
 } 
}

هذا هو نهاية محتوى هذا المقال، نأمل أن يكون قد ساعدكم في التعلم، ونأمل أيضًا أن تشجعوا دليل التعليمات.

البيان: محتوى هذا المقال تم جمعه من الإنترنت، حقوق النشر مملوكة للمالك الأصلي، تم جمع المحتوى من إسهامات المستخدمين عبر الإنترنت وتم تحميله بشكل تلقائي، هذا الموقع لا يملك حقوق الملكية، لم يتم تعديل المحتوى بشكل يدوي ولا يتحمل أي مسؤولية قانونية متعلقة بذلك. إذا رأيت محتوى يشتبه في انتهاك حقوق النسخ، يرجى إرسال بريد إلكتروني إلى: notice#oldtoolbag.com (عند إرسال البريد الإلكتروني، يرجى استبدال '#' بـ '@') للإبلاغ، وتقديم الدليل ذات الصلة، إذا تم التحقق من ذلك، سيتم حذف المحتوى المزعوم فورًا.