Goyave Cache cache local (LoadingCache)

Dans l'application de développement, qui ne peut pas utiliser le cache, cache distribué habituellement utilisé, Redis Memcache et autres couramment utilisés, un grand nombre de cache local qui est également utilisé comme ehcache 

Aujourd'hui, Google goyave introduit dans le cadre fourni par le bouchon LoadingCache cache local, LoadingCache et ConcurrentMap sont thread-safe similaire, mais plus que ConcurrentMap d'autres fonctionnalités, telles que les stratégies expirés

avantage

1, cache thread-safe, et ConcurrentMap similaires, mais les premiers éléments plus politiques d'expiration ajoutée, la suppression d' éléments qui ne peuvent être affichés.
2, propose trois méthodes de récupération du cache de base: basé sur le recyclage de récupération des capacités de référence, la récupération et un calendrier basé. récupération de la synchronisation de deux façons: en fonction du temps d'écriture, la première récupération d'écriture plus tôt, en fonction du temps d'accès, la première retrouvks accessible.
3, cache surveillance de la charge / la situation a frappé.
4 intègre de multiples opérations, les appels se façon, vous pouvez mettre en cache manquer lors de l' acquisition source de données (DB, Redis) d'ailleurs, et chargés dans le cache

 

Aisément écrire une classe simple (d'amélioration)

package com.shentb.hmb.cache;

import com.google.common.cache.*;
import com.shentb.hmb.service.impl.LoginService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

@Component
public final class LoadingLocalCache {

    private static LoginService loginService;

    private static Logger logger = LoggerFactory.getLogger(LoadingLocalCache.class);

    private static LoadingCache<String, Object> loadingCache;

    private static LoadingLocalCache loadingLocalCache;

    private static int DEFAULT_CONCURRENCY_LEVEL= 4;

    private static int DEFAULT_EXPIRE= 1800;

    private static int DEFAULT_INITIAL_CAPACITY= 16;

    private static int DEFAULT_MAXIMUM_SIZE= 100;

    private static TimeUnit DEFAULT_TIME_UNIT= TimeUnit.SECONDS;

    @Autowired
    public void setLoginService(LoginService loginService) {
        LoadingLocalCache.loginService = loginService;
    }

    static {
        init();
    }

    private LoadingLocalCache(){}

    protected static void init() {
        loadingCache= CacheBuilder
                .newBuilder()
                //并发级别（同时写入缓存的线程数）
                .concurrencyLevel(DEFAULT_CONCURRENCY_LEVEL)
                //过期时间
                .expireAfterWrite(DEFAULT_EXPIRE,DEFAULT_TIME_UNIT)
                //初始容量
                .initialCapacity(DEFAULT_INITIAL_CAPACITY)
                //最大容量,超过之后默认按照LRU算法最近使用最少移除缓存项    
                .maximumSize(DEFAULT_MAXIMUM_SIZE)
                //设置统计缓存的命中率
                .recordStats()
                .removalListener(new RemovalListener<Object, Object>() {
                    @Override
                    public void onRemoval(RemovalNotification<Object, Object> notification) {
                        logger.info(notification.getKey() + " was removed, cause is " + notification.getCause());
                    }
                })
                //build方法中可以指定CacheLoader，在缓存不存在时通过CacheLoader的实现自动加载缓存
                .build(
                        new CacheLoader<String, Object>() {
                            @Override
                            public Object load(String key) throws Exception {
                                return loginService.selectByPhoneNo(key);
                            }
                        }
                );
    }

    public static Object put(String key, Object value){
        loadingCache.put(key, value);
        return value;
    }

    public static Object get(String key) throws Exception {
        return loadingCache.get(key);
    }

    public static <T> T checkNotNull(T reference) {
        if (reference == null) {
            throw new NullPointerException();
        }
        return reference;
    }


//        System.out.println(sellerContactVOCache.stats().toString());
}

Les méthodes courantes:

GET (K) : Cette méthode soit renvoie la valeur mise en cache, CacheLoader le chargement d' une nouvelle valeur dans le cache atomiquement (le moment où le cache est dit ci - dessus, il n'y a pas de valeur pour effectuer méthode Load) ou de l' utilisation

PUT (clé, valeur) : Cette méthode peut être montrée directement insérer une valeur dans le cache, qui directement écrasera la valeur avant la mise en correspondance a été hors clé.

récupération du cache:

CacheBuilder.maximumSize (Long) : Cette méthode nombre spécifié d'entrées de cache ne dépasse pas une valeur fixe (en fait, vous pouvez être comprise comme une carte de la capacité maximale), essayez l'entrée du cache n'est pas retrouvks utilisé ou rarement utilisé sur un ensemble

récupération de rythme (Timed Expulsion):

expireAfterAccess (Long, TimeUnit) : entrée du cache est pas lu dans un temps d' accès / écriture donné, puis récupéré. Notez que cet ordre de récupération et de la même taille de cache à base de récupération.

expireAfterWrite (Long, TimeUnit) : entrée de cache dans un temps donné n'est pas accès en écriture (pour créer ou écraser), puis récupéré. Si les données du cache est toujours indisponible devenir obsolètes après un temps fixe, cette reprise est de manière souhaitable.

Explicite clair:

A tout moment, vous pouvez effacer explicitement l'entrée du cache, plutôt que d'attendre jusqu'à ce qu'il soit recyclé:

clair individuelle: Cache.invalidate (clé)   lot clair: Cache.invalidateAll (Keys)   effacer toutes les entrées du cache: Cache.invalidateAll ()

Supprimer auditeurs

Par CacheBuilder.removalListener (RemovalListener) , vous pouvez déclarer un auditeur de faire quelques opérations supplémentaires lorsque l'entrée de cache est supprimée. Lorsqu'une entrée de cache est supprimée, RemovalListener notification de suppression de [ de RemovalNotification ], qui comprend l' élimination des motifs [ RemovalCause ], les clés et les valeurs