Gava Charger plusieurs clés et obtenir plusieurs éléments

Question

Je voudrais utiliser Guava comme cache mais je n'arrive pas à trouver que Guava a la capacité de me permettre de charger plusieurs éléments et d'obtenir plusieurs éléments.

Je vois CacheLoader les éléments suivants sont:

@Override 
    public Value load(String key) { 
     return getKey(); 
    } 

Et ce que je dois charger est:

@Override 
    public List<Value> load(List<String> keys) { 
     return getKeys(); 
    } 

Je me attends aussi d'obtenir une ou une liste d'éléments du cache, mais Je suis heureux même si je devais envelopper cet élément dans une liste juste pour l'obtenir.

Je suis nouveau à Guava et je ne suis pas sûr si Guava a une telle fonctionnalité?

Answer 1

Vous pouvez créer un LoadingCache (juste pour par exemple) comme:

private final LoadingCache<String, Object> cache; 

où chaîne pourrait être le type de données de votre clé et l'objet pourrait être le type de données de votre valeur.

Vous pouvez ensuite initialiser en utilisant CacheBuilder comme:

cache = CacheBuilder.newBuilder(). 
       initialCapacity(10). 
       maximumSize(50). 
       recordStats(). 
       build(new CacheLoader<String, Object>() { 
        @Override 
        public Object load(String s) throws Exception { 
         return null; 
        } 
       }); 

et encore plus mettre en œuvre des méthodes pour obtenir une valeur à partir du cache en fonction de la clé et mettre une valeur dans le cache pour une paire de valeurs clé dans un peu ce format:

public Object get(String key) { 
    try { 
     return cache.getIfPresent(key); 
    } catch (Exception e) { 
     System.out.println(e.getMessage()); 
     return null; 
    } 
} 

public boolean put(String key, Object object) { 
    cache.put(key, object); 
    return true; 
} 

Answer 2

Vous pouvez utiliser CacheLoader.loadAll() pour charger plusieurs articles et LoadingCache.getAll() pour les obtenir.

Par exemple:

new CacheLoader<String, Value>() { 
    @Override 
    public Value load(String key) { 
     return getKey(); 
    } 

    @Override 
    public Map<String, Value> load(Iterable<? extends String> keys) { 
     return getKeys(); 
    } 
} 
//... 
List<String> keys = Arrays.asList("key1", "key2", "key3"); 
ImmutableMap<String, Value> values = cache.getAll(keys); 

Answer 3

Public class Cache { 
    private Cache<Key, Value> cache; 
    prviate DataDAO cataDao; 

    public Cache(DataDAO dataDao) { 
    _dataDao = DataDAO; 
    cache = CacheBuilder.newBuilder().build(); 
    } 

    public Value getValue(Key key) { 
    Value value; 
    if (cache.getIfPresent(key) == null) { 
     value = dataDao.getById(key); 
     cache.put(key, value); 
     return value; 
    }else{ 
     return cache.getIfPresent(key); 
    } 
    } 

    Public List<Value> getValues(List<Key> keys) { 
    List<Value> values = new ArrayList<>(); 
    List<Key> notInCacheKeys = new ArrayList<>(); 
    for (Key key: keys) { 
     if (cache.getIfPresent(key)) == null) { 
      notInCacheKeys.add(key); 
     } 
    } 
    List<Value> newlyRetrievedValues = _dataDao.getByIds(notInCacheKeys); 
    //Store Keys and Values in order 
    //Return value and list of values from cache 
    } 
} 

J'ai décidé d'abandonner CacheLoader et LoadingCache et juste travailler avec cache directement.