Guayaba caché caché local (LoadingCache)

En el desarrollo de aplicaciones, que no puede utilizar la memoria caché, caché distribuida normalmente utilizado Redis, Memcache y otros de uso común, muchos de la memoria caché local que también se utiliza como ehcache 

Hoy Google guayaba introducido en el marco proporcionado por el tapón LoadingCache caché local, LoadingCache y ConcurrentMap son similares flujos seguros, pero más que ConcurrentMap algunas otras características, como las estrategias caducados

ventaja

1, añadido política de caducidad más elementos thread-safe caché, y ConcurrentMap similar, pero el primero, la eliminación de elementos que sólo se pueden mostrar.
2, proporciona tres métodos básicos de recuperación cache: basado en el reciclaje de recuperación de capacidad de referencia, la recuperación y a-basado de temporización. Recuperación de la temporización de dos maneras: de acuerdo con el tiempo de escritura, la primera recuperación de escritura más antiguo; de acuerdo con el tiempo de acceso, la primera recuperado recientemente.
3, la supervisión de carga cache / situación golpeado.
4 integra múltiples operaciones, llamadas consiguen manera, se puede almacenar en caché se pierda en la adquisición de la fuente de datos (DB), Redis de otros lugares, y se cargan en la memoria caché

 

Fácilmente escribir una clase simple (margen de mejora)

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());
}

Los métodos más comunes:

GET (K) : Este método ya sea devuelve el valor almacenado en caché, CacheLoader cargar un nuevo valor a la memoria caché atómicamente (el tiempo en que la memoria caché se dijo anteriormente, no hay ningún valor para llevar a cabo el método de carga) o el uso

PUT (Key, valor) : Este método se puede demostrar directamente insertar un valor en la memoria caché, que sobrescribirá directamente el valor antes de la cartografía ha estado fuera llave.

la recuperación de la memoria caché:

CacheBuilder.maximumSize (Long) : Este método número determinado de entradas de caché no exceda de un valor fijo (de hecho, puede ser entendido como un mapa de la capacidad máxima), trata la entrada de caché no se recupera poco usada o rara vez se utiliza en una general

recuperación de temporización (Timed desalojo):

expireAfterAccess (Long, TimeUnit) : entrada de caché no se lee dentro de un tiempo de acceso / escritura dada, luego se recuperó. Tenga en cuenta que esta orden de ingreso y la recuperación basados mismo tamaño de caché.

expireAfterWrite (Long, TimeUnit) : entrada de caché en un momento dado no es el acceso de escritura (para crear o sobrescribir), luego se recuperó. Si los datos de caché es siempre rancio estar disponible tras un tiempo fijo, esta recuperación es de manera deseable.

Explícita claro:

En cualquier momento, puede borrar de forma explícita la entrada de caché, en lugar de esperar hasta que se recicla:

Clara individual: Cache.invalidate (Key)   por lotes claro: Cache.invalidateAll (Keys)   borrar todas las entradas de la caché: Cache.invalidateAll ()

Retire los oyentes

Por CacheBuilder.removalListener (RemovalListener) , se puede declarar un oyente que hacer algunas operaciones adicionales cuando se quita la entrada de caché. Cuando se elimina una entrada de caché, RemovalListener obtiene notificación de eliminación [ RemovalNotification ], que comprende la eliminación de las razones [ RemovalCause ], claves y valores