Google Guava verfügt über einen CacheBuilder, mit dem ConcurrentHash mit ablaufenden Schlüsseln erstellt werden kann, mit denen Einträge nach dem festgelegten Timeout entfernt werden können. Ich muss jedoch nur eine Instanz eines bestimmten Typs zwischenspeichern.

Was ist der beste Weg, um einzelne Objekte innerhalb eines festen Timeouts mit Google Guava zwischenzuspeichern?

Ich würde Guava verwenden Suppliers.memoizeWithExpiration (Lieferantendelegierter, lange Dauer, TimeUnit-Einheit)

public class JdkVersionService {

    @Inject
    private JdkVersionWebService jdkVersionWebService;

    // No need to check too often. Once a year will be good :) 
    private final Supplier<JdkVersion> latestJdkVersionCache
            = Suppliers.memoizeWithExpiration(jdkVersionSupplier(), 365, TimeUnit.DAYS);


    public JdkVersion getLatestJdkVersion() {
        return latestJdkVersionCache.get();
    }

    private Supplier<JdkVersion> jdkVersionSupplier() {
        return new Supplier<JdkVersion>() {
            public JdkVersion get() {
                return jdkVersionWebService.checkLatestJdkVersion();
            }
        };
    }
}

Update mit JDK 8

Heute würde ich diesen Code anders schreiben, indem ich JDK 8-Methodenreferenzen und Konstruktorinjektion für saubereren Code verwende:

import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

import javax.inject.Inject;

import org.springframework.stereotype.Service;

import com.google.common.base.Suppliers;

@Service
public class JdkVersionService {

    private final Supplier<JdkVersion> latestJdkVersionCache;

    @Inject
    public JdkVersionService(JdkVersionWebService jdkVersionWebService) {
        this.latestJdkVersionCache = Suppliers.memoizeWithExpiration(
                jdkVersionWebService::checkLatestJdkVersion,
                365, TimeUnit.DAYS
        );
    }

    public JdkVersion getLatestJdkVersion() {
        return latestJdkVersionCache.get();
    }
}