Goiaba Cache cache local (LoadingCache)

Na aplicação desenvolvimento, que não pode usar o cache, cache distribuído Redis, Memcache e normalmente usado outro comumente usado, muitos do cache local que também é usado como ehcache 

Hoje google goiaba introduzida no âmbito do quadro fornecido pelo cache local plugue LoadingCache, LoadingCache e ConcurrentMap são semelhantes thread-safe, mas mais do que ConcurrentMap algumas outras características, tais como estratégias expirados

vantagem

1, acrescentou política mais elementos de expiração thread-safe cache, e ConcurrentMap semelhante, mas o primeiro, remoção de elementos que só podem ser exibidos.
2, proporciona três modos básicos de recuperação de cache: com base na recuperação da capacidade de reciclagem de referência, e uma recuperação de temporização-base. Cronometrando recuperação de duas maneiras: de acordo com o tempo de gravação, a primeira recuperação de gravação mais antiga, de acordo com o tempo de acesso, o primeiro recuperado recentemente acessados.
3, cache de monitoramento de carga / situação atingiu.
4 integra múltiplas operações, chamadas começam a maneira, você pode armazenar em cache perder quando a aquisição de fontes de dados (DB, Redis) de outros lugares, e carregado para o cache

 

Prontamente escrever uma classe simples (espaço para melhorias)

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

Os métodos mais comuns:

GET (K) : Este método, quer retorna o valor em cache, CacheLoader carregar um novo valor para o cache atomicamente (o tempo quando o cache é dito acima, não há nenhum valor para executar método de carga) ou o uso

PUT (chave, valor) : Este método pode ser demonstrado directamente inserir um valor dentro do cache, o qual vai substituir directamente o valor antes do mapeamento tem sido fora da chave.

recuperação de cache:

CacheBuilder.maximumSize (Long) : Este método especificado número de entradas de cache não exceda um valor fixo (na verdade, pode ser entendida como um Mapa da capacidade máxima), tente a entrada de cache não é recuperado recentemente utilizado ou raramente usado em um global

recuperação de temporização (temporizado despejo):

expireAfterAccess (Long, TimeUnit) : entrada de cache não é lido dentro de um determinado tempo de acesso / gravação, depois se recuperou. Note-se que esta ordem de cobrança e recuperação baseados mesmo tamanho de cache.

expireAfterWrite (Long, TimeUnit) : entrada de cache dentro de um determinado tempo não é o acesso de escrita (para criar ou substituir), depois se recuperou. Se os dados de cache é sempre indisponível obsoleto tornar-se depois de um tempo fixo, essa recuperação é maneira desejável.

Explícita clara:

A qualquer momento, você pode limpar explicitamente a entrada de cache, em vez de esperar até que ele é reciclado:

Individual clara: Cache.invalidate (Key)   lote clara: Cache.invalidateAll (Keys)   limpar todas as entradas de cache: Cache.invalidateAll ()

Remover ouvintes

Por CacheBuilder.removalListener (RemovalListener) , você pode declarar um ouvinte para fazer algumas operações adicionais quando a entrada de cache é removida. Quando uma entrada de cache é removido, RemovalListener notificação remoção obtém [ RemovalNotification ], que compreende a remoção dos motivos [ RemovalCause ], chaves e valores