Giriş
Açıklaması
şöyle.
Guava is missing a feature that other caches provide, which is a variable expiry based on the cached value.
1. Population - Cache'i Doldurma
Yöntemler
şöyle.
1. cache.get(...) metodunu kullanarak bir Callable kullanmak
2. cache.put(...) veya cache.putAll() metodları ile değeri direkt vermek
Cache aynı zamanda asMap() metodu ile bir ConcurrentMap döndürüyor. asMap() metodunu kullanarak doldurmak doğru değil. Açıklaması
şöyle.
Values may be inserted into the cache directly with cache.put(key, value). This overwrites any previous entry in the cache for the specified key. Changes can also be made to a cache using any of the ConcurrentMap methods exposed by the Cache.asMap() view. Note that no method on the asMap view will ever cause entries to be automatically loaded into the cache. Further, the atomic operations on that view operate outside the scope of automatic cache loading, so Cache.get(K, Callable) should always be preferred over Cache.asMap().putIfAbsent in caches which load values using either CacheLoader or Callable.
3. CacheBuilder + CacheLoader kullanarak LoadingCache elde etmek. Eğer LoadingCache Kullanıyorsak Bulk Load veya Single Load yapabiliriz.
3.1. Bulk Load için LoadingCache.getAll(Iterable<? extends K>) metodu çağrılır. Bu çağrı CacheLoader.loadAll() metodunu tetikler. Açıklaması
şöyle.
Bulk lookups can be performed with the method getAll(Iterable<? extends K>). By default, getAll will issue a a separate call to CacheLoader.load for each key which is absent from the cache. When bulk retrieval is more efficient than many individual lookups, you can override CacheLoader.loadAll to exploit this. The performance of getAll(Iterable) will improve accordingly.
3.2. LoadingCache.get() metodu çağrılır. Bu çağrı CacheLoader.get() metodunu tetikler. Açıklaması
şöyle.
The canonical way to query a LoadingCache is with the method get(K). This will either return an already cached value, or else use the cache's CacheLoader to atomically load a new value into the cache.
2. Eviction - Cache'ten Silme
Yöntemler
şöyle.
1.
Size-based yöntem. CacheBuilder.maximumSize(), CacheBuilder.weigher() gibi bir yöntem kullanmak
2.
Time based yöntem. CacheBuilder.expireAfterAccess(), CacheBuilder.expireAfterWrite() gibi bir yöntem kullanmak
3. Reference-based Eviction. CacheBuilder.weakKeys(), CacheBuilder.weakValues() , CacheBuilder.softValues() gibi bir yöntem kullanmak
4. Cache.invalidate(key),Cache.invalidateAll(keys),Cache.invalidateAll() metodlarını kullanmak
3. Cleanup
cleanUp() metoduna bakabilirsiniz.
4. Removal Listener
CacheBuilder.removalListener(RemovalListener) ile bir listener takılabilir.
RemovalListener yazısına bakabilirsiniz.
5. Refresh
Yöntemler
şöyle.
1. LoadingCache.refresh(K) ile belirli bir key yenilenebilir. Bu çağrı CacheLoader.reload() metodunu tetikler. CacheLoader.reload(K, V) ile eski value değer ile tetiklenir.
6. Metodlar
asMap metodu
java.util.ConcurrentMap döndürür. Açıklaması
şöyle.
Returns a view of the entries stored in this cache as a thread-safe map. Modifications made to the map directly affect the cache.
Örnek
Şöyle
yaparız.
cache.asMap().compute(key, ...);
Örnek
Şöyle
yaparız.
private static final ConcurrentMap<String, Buffered> IMAGE_MAP =
CacheBuilder.newBuilder()
.softValues()
.<String, Buffered>build()
.asMap();
Örnek
Şöyle
yaparız.
String someValueFromCache = myCache.asMap().get("someString");
cleanUp metodu
Açıklaması
şöyle. Cache evict işlemini yapmak için bu metod
çağrılır.
Caches built with CacheBuilder do not perform cleanup and evict values "automatically," or instantly after a value expires, or anything of the sort. Instead, it performs small amounts of maintenance during write operations, or during occasional read operations if writes are rare.
The reason for this is as follows: if we wanted to perform Cache maintenance continuously, we would need to create a thread, and its operations would be competing with user operations for shared locks. Additionally, some environments restrict the creation of threads, which would make CacheBuilder unusable in that environment.
Instead, we put the choice in your hands. If your cache is high-throughput, then you don't have to worry about performing cache maintenance to clean up expired entries and the like. If your cache does writes only rarely and you don't want cleanup to block cache reads, you may wish to create your own maintenance thread that calls Cache.cleanUp() at regular intervals.
If you want to schedule regular cache maintenance for a cache which only rarely has writes, just schedule the maintenance using ScheduledExecutorService.
get metodu - Key
Açıklaması şöy
le.
There's no way to prevent caching an object if you obtain it via Cache.get.
Örnek
Şöyle
yaparız.
cache.get(key, new Callable() {...});
Örnek
Şöyle
yaparız.
LoadingCache<String, List<Profile>> loadingCache = ...;
public List<Profile> getProfileByFields(String id, String name) throws Exception {
String key = id.toLowerCase() + "|" + name.toLowerCase()
return loadingCache.get(key);
}
getIfPresent metodu - Key
null dönebilir.
Örnek
Şöyle
yaparız.
MyObject o = cache.getIfPresent(key);
if (o == null) {
o = getExternal(key);
if (o.isActive()) {
cache.put(key, o);
}
}
Örnek
Elimizde şöyle bir kod
olsun.
Cache<String, Integer> forgetPasswordCache = CacheBuilder.newBuilder()
.expireAfterAccess(24, TimeUnit.HOURS)
.build();
Eğer değer üst sınırı aşarsa konrolü yapmak için şöyle
yaparız.
final String email = ...;
Integer currentCount = forgetPasswordCache.getIfPresent(email);
if (currentCount != null && currentCount >= RESET_PASSWORD_MAX_ATTEMPTS) {
logger.error("User with id: " + user.getId() + " and email: " + email +
" has reached the maximum number of reset password attempts, the mail will not be
sent");
return;
}
if (currentCount == null) {
forgetPasswordCache.put(email, new Integer(1));
} else {
forgetPassworCache.put(email, new Integer(currentCount + 1));
}
invalidate metodu
Belirtilen key değerine sahip cache nesnesini siler. Şöyle
yaparız.
MyObject o = cache.get(key, () -> getExternal(key));
if (!o.isActive()) {
cache.invalidate(key);
}
invalidateAll metodu
Tüm cache'i siler. Şöyle
yaparız.
cache.invalidateAll();
maximumSize metodu - Size Based Cache Temizleme
Açıklaması
şöyle.
If your cache should not grow beyond a certain size, just use CacheBuilder.maximumSize(long). The cache will try to evict entries that haven't been used recently or very often. Warning: the cache may evict entries before this limit is exceeded -- typically when the cache size is approaching the limit.
put metodu
Örnek
Şöyle
yaparız
Cache<String, RateLimiter> cache = ...
public boolean tryAcquire(String key, double secondsBeforeNextOperation) {
RateLimiter rateLimiter = cache.getIfPresent(key);
if (rateLimiter == null) {
rateLimiter = getNewRateLimiter(secondsBeforeNextOperation);
cache.put(key, rateLimiter);
}
return rateLimiter.tryAcquire();
}
Örnek
Şöyle
yaparız.
myCache.put("someString", "someString");
String someValueFromCache = myCache.get("someString");
putAll metodu
İmzası
şöyle
void putAll(Map<? extends K, ? extends V> map);
size metodu
İmzası
şöyle.
long size()
Açıklaması
şöyle.
Returns the approximate number of entries in this cache.