So legen Sie die Ablaufzeitkarte in Java fest

1. Technischer Hintergrund

In der tatsächlichen Projektentwicklung verwenden wir häufig Caching-Middleware (wie Redis, MemCache usw.), um die Verfügbarkeit und Robustheit des Systems zu verbessern.

Wenn das Projekt jedoch relativ einfach ist, besteht in vielen Fällen keine Notwendigkeit, Middleware wie Redis speziell für die Verwendung des Caches einzuführen, um die Komplexität des Systems zu erhöhen. Verfügt Java selbst über nützliche, leichtgewichtige Caching-Komponenten?

Die Antwort ist natürlich ja, und es gibt mehr als einen Weg. Zu den gängigen Lösungen gehören: ExpiringMap-, LoadingCache- und HashMap-basierte Paketierung.

2. Technischer Effekt

• Verwirklichen Sie allgemeine Funktionen des Caches, z. B. eine veraltete Löschstrategie

  Sie können das einstellen Der Eintrag in der Karte erlischt automatisch nach einer bestimmten Zeitspanne.

• Sie können den maximalen Kapazitätswert der Karte festlegen. Wenn die maximale Größe erreicht ist, verfällt durch erneutes Einfügen eines Werts der erste Wert in der Karte.

Sie können Hörereignisse hinzufügen und die Hörfunktion planen, wenn der Eintrag abläuft.

• Sie können Lazy Loading einrichten und Objekte erstellen, wenn die Methode get() aufgerufen wird.

• 3.2 Quellcode
  github-Adresse
• 3.3 Beispiel
  Abhängigkeiten hinzufügen (Maven)

<dependency> 
    <groupId>net.jodah</groupId> 
    <artifactId>expiringmap</artifactId> 
    <version>0.5.8</version> 
</dependency>

• Beispielquellcode

  public class ExpiringMapApp {
  
      public static void main(String[] args) {
          // maxSize: 设置最大值,添加第11个entry时，会导致第1个立马过期(即使没到过期时间)
          // expiration：设置每个key有效时间10s, 如果key不设置过期时间，key永久有效。
          // variableExpiration: 允许更新过期时间值,如果不设置variableExpiration，不允许后面更改过期时间,一旦执行更改过期时间操作会抛异常UnsupportedOperationException
          // policy:
          //        CREATED: 只在put和replace方法清零过期时间
          //        ACCESSED: 在CREATED策略基础上增加, 在还没过期时get方法清零过期时间。
          //        清零过期时间也就是重置过期时间，重新计算过期时间.
          ExpiringMap<String, String> map = ExpiringMap.builder()
              .maxSize(10)
              .expiration(10, TimeUnit.SECONDS)
              .variableExpiration().expirationPolicy(ExpirationPolicy.CREATED).build();
  
          map.put("token", "lkj2412lj1412412nmlkjl2n34l23n4");
          map.put("name", "管理员", 20000, TimeUnit.SECONDS);
  
          // 模拟线程等待...
          try {
              Thread.sleep(15000);
          } catch (InterruptedException e) {
              e.printStackTrace();
          }
  
          System.out.println("token ===> " + map.get("token"));
          System.out.println("name ===> " + map.get("name"));
  
          // 注意： 在创建map时，指定的那些参数如过期时间和过期策略都是全局的, 对map中添加的每一个entry都适用.
          //        在put一个entry键值对时可以对当前entry 单独设置 过期时间、过期策略,只对当前这个entry有效.
      }
  }

  Ergebnisse ausführen

token ===> null

name === > Administrator

Hinweis

Beim Erstellen einer Karte sind die angegebenen Parameter wie Ablaufzeit und Ablaufrichtlinie global und gelten für jeden zur Karte hinzugefügten Eintrag.

Beim Einfügen eines Eintrags-Schlüssel-Wert-Paares können Sie die Ablaufzeit und die Ablaufrichtlinie separat für den aktuellen Eintrag festlegen, die nur für den aktuellen Eintrag gültig ist.

4. LoadingCache

4.1 Funktionseinführung

Ein Thread-sicher Lokaler Cache, Open-Source-Lösung von Google.

Funktionen: Bereitstellung eines Cache-Recycling-Mechanismus, Überwachung des Cache-Lade-/Trefferstatus, flexible und leistungsstarke Funktionen, einfache und benutzerfreundliche API.

4.2 Beispiel

Quellcode

public class LoadingCacheApp {

    public static void main(String[] args) throws Exception {
        // maximumSize: 缓存池大小，在缓存项接近该大小时， Guava开始回收旧的缓存项
        // expireAfterAccess: 设置时间对象没有被读/写访问则对象从内存中删除(在另外的线程里面不定期维护)
        // removalListener: 移除监听器,缓存项被移除时会触发的钩子
        // recordStats: 开启Guava Cache的统计功能
        LoadingCache<String, String> cache = CacheBuilder.newBuilder()
            .maximumSize(100)
            .expireAfterAccess(10, TimeUnit.SECONDS)
            .removalListener(new RemovalListener<String, String>() {
                @Override
                public void onRemoval(RemovalNotification<String, String> removalNotification) {
                    System.out.println("过时删除的钩子触发了... key ===> " + removalNotification.getKey());
                }
            })
            .recordStats()
            .build(new CacheLoader<String, String>() {
                // 处理缓存键不存在缓存值时的处理逻辑
                @Override
                public String load(String key) throws Exception {
                    return "不存在的key";
                }
            });

        cache.put("name", "小明");
        cache.put("pwd", "112345");

        // 模拟线程等待...
        try {
            Thread.sleep(15000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("token ===> " + cache.get("name"));
        System.out.println("name ===> " + cache.get("pwd"));
    }
}

Laufende Ergebnisse

Der veraltete Lösch-Hook wird ausgelöst... key ===> name

token ===> Nicht vorhandener Schlüssel

Der veraltete Lösch-Hook wird ausgelöst .. key ===> pwd

name ===> Nicht vorhandener Schlüssel

4.3 Entfernungsmechanismus

Wenn Guave Daten zwischenspeichert, gibt es zwei Arten der Datenentfernung: passive Entfernung und aktive Entfernung.

Passive Entfernung

Größenbasierte Entfernung: Wenn die Menge die angegebene Größe erreicht, werden ungewöhnliche Schlüsselwerte entfernt

Zeitbasierte Entfernung: ExpireAfterAccess(long, TimeUnit) basierend auf einem bestimmten Schlüsselwert Wie lange nach dem letzten Besuch, um entfernt zu werden? ExpireAfterWrite(long, TimeUnit) Entfernen Sie basierend auf der Zeit nach der Erstellung eines Schlüssel-Wert-Paares oder dem Ersetzen des Werts oder Wert Entfernen: Aktive Entfernung: Cache.invalidate(key)

Wenn der Entfernungs-Listener RemovalListener konfiguriert ist, wird die Logik unter dem Listener bei allen Entfernungsaktionen synchron ausgeführt.

Wenn Sie zu asynchron wechseln müssen, verwenden Sie: RemovalListeners.asynchronous(RemovalListener, Executor).

4.4 Andere

• Wenn der Schlüsselwert vor dem Put-Vorgang bereits vorhanden ist, wird zuerst RemoveListener ausgelöst, um den Listener zu entfernen , und dann hinzufügen

• „expireAfterAccess“ und „expireAfterWrite“ sind konfiguriert, werden aber nach der angegebenen Zeit nicht entfernt.

• Löschstrategielogik:

Der von CacheBuilder erstellte Cache führt zu einem bestimmten Zeitpunkt keine automatischen Reinigungs- und Recyclingarbeiten durch und wird auch nicht sofort nach Ablauf eines Cache-Elements bereinigt. Es wird kein Thread zum Caching gestartet Wartung, da Threads erstens relativ schwer sind und zweitens einige Umgebungen die Erstellung von Threads einschränken.

• Bei Schreibvorgängen oder gelegentlich auch bei Lesevorgängen werden geringfügige Wartungsarbeiten durchgeführt. Natürlich können Sie auch einen eigenen Wartungsthread erstellen und Cache.cleanUp() in festen Abständen aufrufen.

Das obige ist der detaillierte Inhalt vonSo legen Sie die Ablaufzeitkarte in Java fest. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!