Odśwież EHCache

Question

W EHCache, czy istnieje sposób na wdrożenie jakiegoś odbiornika db, w którym kahka zostanie automatycznie zaktualizowany, jeśli dane nie są zsynchronizowane? (np. gdy tylko użytkownik zażąda danych, kelce sprawdza, czy dane nie są zsynchronizowane, jeśli tak ... aktualizuje się i zwraca dane, jeśli nie ... po prostu zwróć dane z pamięci podręcznej) Jeśli ktoś może Wskaż mi, która część specyfikacji podkreśla to wykorzystanie, które byłoby niesamowite!

Celem jest zawsze dostarczanie użytkownikowi najnowszych danych. Zgaduję, że mechanizm odświeżania w czasie nie będzie działał, ponieważ dane mogą się zmienić w dowolnym momencie.

ehcache nie jest obowiązkowe, aby korzystać w moim przypadku, więc każdy mechanizm, który spełnia ten będzie najbardziej mile widziane ...

Dzięki !!

Answer 1

Dla EhCache this jest to, co myślę, że szukasz. Jeśli nie chcesz zrobić odświeżonego czasu (nawet jeśli jest to proste rozwiązanie), wyzwalacze lub aktualizacja oparta na magistrali komunikatów będzie do zrobienia. Możesz wykonać niektóre statystyki i zobaczyć częstotliwość aktualizacji po ustaleniu wyzwalania i przełączyć się na aktualizację czasową z odpowiednią częstotliwością, aby spełnić wymagania Nyquist.

Answer 2

Zrobiłem to za pomocą adnotacji sprężynowych ehcache. To są moje zależności w pom.xml maven

<dependency> 
    <groupId>org.springframework</groupId> 
    <artifactId>spring-core</artifactId> 
    <version>3.0.5.RELEASE</version> 
</dependency> 
<dependency> 
    <groupId>net.sf.ehcache</groupId> 
    <artifactId>ehcache-core</artifactId> 
    <version>2.2.0</version> 
</dependency> 
    <dependency> 
    <groupId>com.googlecode.ehcache-spring-annotations</groupId> 
    <artifactId>ehcache-spring-annotations</artifactId> 
    <version>1.2.0-M1</version> 
</dependency> 

prace @Cacheable, ale niestety @TriggersRemove nie działa. Rozwiązaniem jest ręczne unieważnienie pamięci podręcznej. Oto mój przykład użycia:

package com.company.project.dao; 

import java.util.List; 

import net.sf.ehcache.CacheManager; 
import net.sf.ehcache.Ehcache; 

import org.hibernate.SessionFactory; 
import org.springframework.beans.factory.FactoryBean; 
import org.springframework.beans.factory.annotation.Autowired; 
import org.springframework.beans.factory.annotation.Qualifier; 
import org.springframework.stereotype.Component; 
import org.springframework.transaction.annotation.Propagation; 
import org.springframework.transaction.annotation.Transactional; 

import com.company.project.domain.Parent; 
import com.company.project.domain.Child; 

import com.googlecode.ehcache.annotations.Cacheable; 
import com.googlecode.ehcache.annotations.KeyGenerator; 
import com.googlecode.ehcache.annotations.Property; 

@Component("Example") 
public class EhcacheExample { 

    @Autowired 
    @Qualifier("ehCacheManager") 
    private FactoryBean<CacheManager> ehCacheManager; 

    public void createParen(Parent parent) { 
     cleanCache(parent); 
     create(parent); 
    } 

    private void cleanCache(Parent parent) { 
     try { 
      CacheManager cacheManager = ehCacheManager.getObject(); 
      Ehcache ehcache = cacheManager.getEhcache("myCache"); 
      ehcache.remove(parent.getChild().hashCode()); 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
    } 

    @Cacheable 
    ( cacheName = "myCache", 
     keyGenerator = @KeyGenerator (   
      name = "com.company.project.util.ChildCacheKeyGenerator",     
      properties = @Property(name="includeMethod", value="false") 
     ) 
    ) 
    public List<SerieRecording> getParentsByChild(Child child) { 
     return ...; 
    } 

    @Override 
    public void deleteParentById(long id) { 
     Parent parent = findById(id); 
     cleanCache(parent); 
     delete(parent); 
    } 

... 
} 

Realizacja KeyGenerator może być:

package com.company.project.util; 

import java.io.Serializable; 

import org.slf4j.Logger; 
import org.slf4j.LoggerFactory; 

import com.company.project.domain.Child; 

import com.googlecode.ehcache.annotations.key.AbstractCacheKeyGenerator; 


public class ChildCacheKeyGenerator extends AbstractCacheKeyGenerator<Serializable> { 

    Logger logger = LoggerFactory.getLogger(this.getClass()); 

    @Override 
    public Serializable generateKey(Object... data) { 

     if (data[0] instanceof Child) { 
      Child child = (Child)data[0]; 
      return child.hashCode(); 
     } 
     new IllegalArgumentException(); 
     return null; 
    } 

} 

W konfiguracji Wiosna:

<bean id="ehCacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean" > 
    <property name="configLocation" value="classpath:config/ehcache-methods.xml"/> 
</bean> 

ehcache-methods.xml:

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
         xsi:noNamespaceSchemaLocation="ehcache.xsd"> 

    <cache name="myCache" eternal="false" 
     maxElementsInMemory="12600" overflowToDisk="false" diskPersistent="false" 
     timeToIdleSeconds="0" timeToLiveSeconds="1800" 
     memoryStoreEvictionPolicy="LRU" /> 

</ehcache> 

Mam nadzieję, że jest to przydatne.