Background
Here is my working (simplified) GenericDao interface, which is implemented by any DomainDao:
GenericDao.java
@NoRepositoryBean
public interface GenericDao<E extends Persistable<K>, K extends Serializable> extends JpaRepository<E, K> {
public List<E> findAll();
public E persist(E entity);
}
GenericDaoImpl.java
public class GenericDaoImpl<E extends Persistable<K>, K extends Serializable> extends SimpleJpaRepository<E, K> implements GenericDao<E, K> {
private final JpaEntityInformation<E, ?> entityInformation;
private final EntityManager em;
private final Class<E> type;
public GenericDaoImpl(JpaEntityInformation<E, ?> entityInformation, EntityManager em) {
super(entityInformation, em);
this.entityInformation = entityInformation;
this.em = em;
this.type = entityInformation.getJavaType();
}
@Override
public List<E> findAll() {
return super.findAll();
}
@Override
@Transactional
public E persist(E entity) {
if (entityInformation.isNew(entity) || !EntityUtils.isPrimaryKeyGenerated(type) && !em.contains(entity)) {
em.persist(entity);
}
return entity;
}
}
For example, to manage the domains Foo and Bar, you just need to create two interfaces as follow:
FooDao.java
public interface FooDao extends GenericDao<Foo, Integer> {
}
BarDao.java
public interface BarDao extends GenericDao<Bar, Integer> {
}
The @Autowired annotation of Spring will automatically instantiate a GenericDaoImpl with the good entity and primary key types.
Problem
I'm now trying to add a caching process on my DAOs, using EhCache and the EhCache Spring Annotations model.
GenericDao.java
@NoRepositoryBean
public interface GenericDao<E extends Persistable<K>, K extends Serializable> extends JpaRepository<E, K> {
@Cacheable(cacheName = "dao")
public List<E> findAll();
@TriggersRemove(cacheName = "dao")
public E persist(E entity);
}
applicationContext.xml
<ehcache:annotation-driven cache-manager="ehCacheManager" />
<bean id="ehCacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean" />
ehcache.xml
<cache name="dao"
eternal="false"
maxElementsInMemory="10000"
overflowToDisk="false"
timeToIdleSeconds="86400"
timeToLiveSeconds="86400"
memoryStoreEvictionPolicy="LFU" />
The problem with the use of a GenericDao, is that the cache should manage each DomainDao independently of each other. For example, with the current configuration, if I call fooDao.findAll(), and then barDao.persist(new Bar()), the cache generated by fooDao.findAll() will be reset, since the same cache would have been used (i.e. <cache name="dao" />), while it shouldn't.
Trails
I tried to implement my own CacheKeyGenerator, that will take into account the type of the calling DomainDao:
applicationContext.xml
<ehcache:annotation-driven cache-manager="ehCacheManager" default-cache-key-generator="daoCacheKeyGenerator" />
<bean id="ehCacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean" />
<bean id="daoCacheKeyGenerator" class="myapp.dao.support.DaoCacheKeyGenerator" />
DaoCacheKeyGenerator.java
public class DaoCacheKeyGenerator implements CacheKeyGenerator<DaoCacheKey> {
@Override
public DaoCacheKey generateKey(MethodInvocation methodInvocation) {
Class<?> clazz = methodInvocation.getThis().getClass().getInterfaces()[0];
Method method = methodInvocation.getMethod();
String methodName = method.getName();
Class<?>[] parameterClasses = method.getParameterTypes();
return new DaoCacheKey(clazz, methodName, parameterClasses);
}
@Override
public DaoCacheKey generateKey(Object... data) {
return null;
}
}
DaoCacheKey.java
public class DaoCacheKey implements Serializable {
private static final long serialVersionUID = 338466521373614710L;
private Class<?> clazz;
private String methodName;
private Class<?>[] parameterClasses;
public DaoCacheKey(Class<?> clazz, String methodName, Class<?>[] parameterClasses) {
this.clazz = clazz;
this.methodName = methodName;
this.parameterClasses = parameterClasses;
}
@Override
public boolean equals(Object obj) { // <-- breakpoint
if (obj instanceof DaoCacheKey) {
DaoCacheKey other = (DaoCacheKey) obj;
if (clazz.equals(other.clazz)) {
// if @TriggersRemove, reset any cache generated by a find* method of the same DomainDao
boolean removeCache = !methodName.startsWith("find") && other.methodName.startsWith("find");
// if @Cacheable, check if the result has been previously cached
boolean getOrCreateCache = methodName.equals(other.methodName) && Arrays.deepEquals(parameterClasses, other.parameterClasses);
return removeCache || getOrCreateCache;
}
}
return false;
}
@Override
public int hashCode() { // <-- breakpoint
return super.hashCode();
}
}
The problem with the above DaoCacheKey, is that the equals method get never called (the program never breaks at least), but the hashCode one does, so the algorithm can't get applied.
Question
Has anyone already managed such a cache? If yes how? Does my try is relevant? If yes, how to make the equals method called, instead of the hashCode one? By extending an existing CacheKeyGenerator? If yes, which one?
Here is the working solution I finally adopted. Just few precisions: my domains all implement the Persistable interface of Spring. Moreover, since I'm using reflection, I'm not sure the time saved by the caching process won't be a bit reduced...
applicationContext.xml
<ehcache:annotation-driven cache-manager="ehCacheManager" default-cache-key-generator="daoCacheKeyGenerator" />
<bean id="ehCacheManager" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean" />
<bean id="daoCacheKeyGenerator" class="myapp.dao.support.cache.DaoCacheKeyGenerator" />
DaoCacheKeyGenerator.java (using the gentyref library)
public class DaoCacheKeyGenerator implements CacheKeyGenerator<DaoCacheKey> {
@SuppressWarnings("unchecked")
@Override
public DaoCacheKey generateKey(MethodInvocation methodInvocation) {
Method method = methodInvocation.getMethod();
Class<? extends GenericDao<?, ?>> daoType = (Class<? extends GenericDao<?, ?>>) methodInvocation.getThis().getClass().getInterfaces()[0];
Class<? extends Persistable<?>> domainType = getDomainType(daoType);
String methodName = method.getName();
Class<?>[] parameterTypes = method.getParameterTypes();
Object[] parameters = methodInvocation.getArguments();
return new DaoCacheKey(domainType, methodName, parameterTypes, parameters);
}
@SuppressWarnings("unchecked")
private Class<? extends Persistable<?>> getDomainType(Class<?> daoType) {
Type baseDaoType = GenericTypeReflector.getExactSuperType(daoType, GenericDao.class);
ParameterizedType parameterizedBaseDaoType = (ParameterizedType) baseDaoType;
return (Class<? extends Persistable<?>>) parameterizedBaseDaoType.getActualTypeArguments()[0];
}
@Override
public DaoCacheKey generateKey(Object... data) {
return null;
}
}
DaoCacheKey.java
public class DaoCacheKey implements Serializable {
private static final long serialVersionUID = 338466521373614710L;
private Class<? extends Persistable<?>> domainType;
private String methodName;
private Class<?>[] parameterTypes;
private Object[] parameters;
public DaoCacheKey(Class<? extends Persistable<?>> domainType, String methodName, Class<?>[] parameterTypes, Object[] parameters) {
this.domainType = domainType;
this.methodName = methodName;
this.parameterTypes = parameterTypes;
this.parameters = parameters;
}
public Class<? extends Persistable<?>> getDomainType() {
return domainType;
}
@Override
public boolean equals(Object obj) {
return this == obj || obj instanceof DaoCacheKey && hashCode() == obj.hashCode();
}
@Override
public int hashCode() {
return Arrays.hashCode(new Object[] { domainType, methodName, Arrays.asList(parameterTypes), Arrays.asList(parameters) });
}
}
ehcache.xml
<cache name="dao"
eternal="false"
maxElementsInMemory="10000"
overflowToDisk="false"
timeToIdleSeconds="86400"
timeToLiveSeconds="86400"
memoryStoreEvictionPolicy="LFU">
<cacheEventListenerFactory class="myapp.dao.support.cache.DaoCacheEventListenerFactory" />
</cache>
DaoCacheEventListenerFactory.java
public class DaoCacheEventListenerFactory extends CacheEventListenerFactory {
@Override
public CacheEventListener createCacheEventListener(Properties properties) {
return new DaoCacheEventListener();
}
}
DaoCacheEventListener.java
public class DaoCacheEventListener implements CacheEventListener {
@SuppressWarnings("unchecked")
@Override
public void notifyElementRemoved(Ehcache cache, Element element) throws CacheException {
DaoCacheKey daoCachekey = (DaoCacheKey) element.getKey();
List<Class<? extends Persistable<?>>> impacts = getOneToManyImpacts(daoCachekey.getDomainType());
for (DaoCacheKey daoCachedkey : (List<DaoCacheKey>) cache.getKeys()) {
if (impacts.contains(daoCachedkey.getDomainType())) {
cache.remove(daoCachedkey);
}
}
}
@SuppressWarnings("unchecked")
private List<Class<? extends Persistable<?>>> getOneToManyImpacts(Class<? extends Persistable<?>> domainType) {
List<Class<? extends Persistable<?>>> impacts = new ArrayList<Class<? extends Persistable<?>>>();
impacts.add(domainType);
for (Method method : domainType.getDeclaredMethods()) {
if (method.isAnnotationPresent(OneToMany.class)) {
ParameterizedType parameterizedType = (ParameterizedType) method.getGenericReturnType();
Class<? extends Persistable<?>> impactedDomainType = (Class<? extends Persistable<?>>) parameterizedType.getActualTypeArguments()[0];
if (!impacts.contains(impactedDomainType)) {
impacts.addAll(getOneToManyImpacts(impactedDomainType));
}
}
}
return impacts;
}
@Override
public void notifyElementPut(Ehcache cache, Element element) throws CacheException {
}
@Override
public void notifyElementUpdated(Ehcache cache, Element element) throws CacheException {
}
@Override
public void notifyElementExpired(Ehcache cache, Element element) {
}
@Override
public void notifyElementEvicted(Ehcache cache, Element element) {
}
@Override
public void notifyRemoveAll(Ehcache cache) {
}
@Override
public void dispose() {
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
Hope that could help ;)
来源：https://stackoverflow.com/questions/14259165/trying-to-use-ehcache-using-spring-and-a-custom-genericdao-interface-that-extend