/eu.etaxonomy.taxeditor.cdmlib/src/main/java/eu/etaxonomy/taxeditor/remoting/cache/CacheLoader.java - Diff - EDIT - EDIT Project Management

« Previous | Next »

Revision 348d552a

Added by Cherian Mathew about 9 years ago

ID 348d552a9000ccf93b9abcf8a133e6883af1e0df
Parent bb534368
Child ba0d4c2f

AbstractPersistentCollection : fixed loading of collection
MockCdmEntitySessionManager, MockCdmEntitySession, ICdmEntitySessionManager, ICdmEntitySession, CdmEntitySessionManager,
CdmEntitySession : added new load method with choice to update client object graph
TermServiceRequestExecutor : using cacher instead of cache
ICachedCommonService, CachedCommonServiceImpl, ProxyUtils : moved utility methods to utility class
CdmServiceRequestExecutor : updating client object graph when calling merge
EntityCacherDebugResult : corrections for output string
CdmTransientEntityCacher : corrected cache configuration, added load methods with update choice, added service cacher check before put
CacheLoader : checking in recursive call if collection and maps are already visited
CdmRemotingException : added constructor with exception as argument
CdmServiceCacher : corrected cache configuration and loading of entities from default cache

         private final Cache cdmlibModelCache;
         private final ICdmCacher cdmServiceCacher;
         public CacheLoader(ICdmCacher cdmCacher) {
             this(cdmCacher, null);
+        }
         public CacheLoader(ICdmCacher cdmCacher, ICdmCacher cdmServiceCacher) {
             this.cdmCacher = cdmCacher;
             this.cdmlibModelCache = CdmRemoteCacheManager.getInstance().getCdmModelGetMethodsCache();
             this.cdmServiceCacher = cdmServiceCacher;
+        }
-...
+        }
         @SuppressWarnings("unchecked")
         public <T extends Object> T load(T obj, boolean recursive) {
         public <T extends Object> T load(T obj, boolean recursive, boolean update) {
             if(obj == null) {
                 return null;
+            }
             if(obj instanceof CdmBase) {
                 return (T) load((CdmBase)obj, recursive);
                 return (T) load((CdmBase)obj, recursive, update);
             } else if (obj instanceof Map) {
                 return (T) load((Map<T,T>)obj, recursive);
                 return (T) load((Map<T,T>)obj, recursive, update);
             } else if (obj instanceof Collection) {
                 return (T) load((Collection<T>)obj, recursive);
                 return (T) load((Collection<T>)obj, recursive, update);
+            }
             return obj;
+        }
         @SuppressWarnings("unchecked")
         private <T extends Object> T loadRecursive(T obj, Set<CdmBase> alreadyVisitedEntities) {
         private <T extends Object> T loadRecursive(T obj, Set<Object> alreadyVisitedEntities, boolean update) {
             if(obj == null) {
                 return null;
+            }
             if(obj instanceof CdmBase) {
                 return (T) loadRecursive((CdmBase)obj, alreadyVisitedEntities);
                 return (T) loadRecursive((CdmBase)obj, alreadyVisitedEntities, update);
             } else if (obj instanceof Map) {
                 return (T) load((Map<T,T>)obj, alreadyVisitedEntities);
                 return (T) load((Map<T,T>)obj, alreadyVisitedEntities, update);
             } else if (obj instanceof Collection) {
                 return (T) load((Collection<T>)obj, alreadyVisitedEntities);
                 return (T) load((Collection<T>)obj, alreadyVisitedEntities, update);
+            }
-...
             return obj;
+        }
         public <T extends Object> Map<T,T> load(Map<T,T> map, boolean recursive){
             if(map == null) {
                 return null;
+            }
         public <T extends Object> Map<T,T> load(Map<T,T> map, boolean recursive, boolean update){
             if(isRecursiveEnabled && recursive) {
                 logger.info("---- starting recursive load for cdm entity map");
                 Set<CdmBase> alreadyVisitedEntities = new HashSet<CdmBase>();
                 Map<T,T> cachedMap = load(map, alreadyVisitedEntities);
                 Set<Object> alreadyVisitedEntities = new HashSet<Object>();
                 Map<T,T> cachedMap = load(map, alreadyVisitedEntities, update);
                 alreadyVisitedEntities.clear();
                 logger.info("---- ending recursive load for cdm entity map \n");
                 return cachedMap;
             } else {
                 return load(map, null);
                 return load(map, null, update);
+            }
+        }
         private <T extends Object> Map<T,T> load(Map<T,T> map, Set<CdmBase> alreadyVisitedEntities){
         private <T extends Object> Map<T,T> load(Map<T,T> map, Set<Object> alreadyVisitedEntities, boolean update){
             //map = (Map<T,T>)deproxy(map);
             if(map == null || map.isEmpty()) {
                 return map;
+            }
-...
             Object[] result = new Object[ map.size() * 2 ];
             Iterator<Map.Entry<T,T>> iter = map.entrySet().iterator();
             int i=0;
             // to avoid ConcurrentModificationException
             alreadyVisitedEntities.add(map);
             while ( iter.hasNext() ) {
                 Map.Entry<T,T> e = iter.next();
                 result[i++] = e.getKey();
-...
             for(i=0; i<result.length;i++) {
                 if(alreadyVisitedEntities == null) {
                     result[i] = load(result[i], false);
                     result[i] = load(result[i], false, update);
                 } else {
                     result[i] = loadRecursive(result[i], alreadyVisitedEntities);
                     result[i] = loadRecursive(result[i], alreadyVisitedEntities, update);
+                }
+            }
             map.clear();
-...
             return map;
+        }
         public <T extends Object> Collection<T> load(Collection<T> collection, boolean recursive){
             if(collection == null) {
                 return null;
+            }
         public <T extends Object> Collection<T> load(Collection<T> collection, boolean recursive, boolean update){
             Collection<T> loadedCollection;
             if(isRecursiveEnabled && recursive) {
                 logger.info("---- starting recursive load for cdm entity collection");
                 Set<CdmBase> alreadyVisitedEntities = new HashSet<CdmBase>();
                 Collection<T> cachedCollection = load(collection, alreadyVisitedEntities);
                 Set<Object> alreadyVisitedEntities = new HashSet<Object>();
                 Collection<T> cachedCollection = load(collection, alreadyVisitedEntities, update);
                 alreadyVisitedEntities.clear();
                 logger.info("---- ending recursive load for cdm entity collection \n");
                 loadedCollection = cachedCollection;
             } else {
                 loadedCollection = load(collection, null);
                 loadedCollection = load(collection, null, update);
+            }
             return loadedCollection;
+        }
         @SuppressWarnings("unchecked")
         private <T extends Object> Collection<T> load(Collection<T> collection, Set<CdmBase> alreadyVisitedEntities){
         private <T extends Object> Collection<T> load(Collection<T> collection, Set<Object> alreadyVisitedEntities, boolean update) {
             if(collection == null || collection.isEmpty()) {
                 return collection;
+            }
             int length = collection.size();
             Object[] result = new Object[length];
             Iterator<T> collectionItr = collection.iterator();
             int count = 0;
             // to avoid ConcurrentModificationException
             alreadyVisitedEntities.add(collection);
             while(collectionItr.hasNext()) {
                 Object obj = collectionItr.next();
                 if(alreadyVisitedEntities == null) {
                     result[count] = load(obj, false);
                     result[count] = load(obj, false, update);
                 } else {
                     result[count] = loadRecursive(obj, alreadyVisitedEntities);
                     result[count] = loadRecursive(obj, alreadyVisitedEntities, update);
+                }
                 count++;
-...
          * @param uuid
          * @param cdmEntity
          */
         public CdmBase load(CdmBase cdmEntity, boolean recursive) {
         public CdmBase load(CdmBase cdmEntity, boolean recursive, boolean update) {
             if(cdmEntity == null) {
                 return null;
+            }
-...
                 if(cachedCdmEntity == cdmEntity) {
                     return cachedCdmEntity;
+                }
                 return cachedCdmEntity;
+            }
             CdmBase loadedCdmBase;
             if(isRecursiveEnabled && recursive) {
                 logger.info("---- starting recursive load for cdm entity " + cdmEntity.getClass().getName() + " with id " + cdmEntity.getId());
                 Set<CdmBase> alreadyVisitedEntities = new HashSet<CdmBase>();
                 CdmBase cb =  loadRecursive(cdmEntity, alreadyVisitedEntities);
                 Set<Object> alreadyVisitedEntities = new HashSet<Object>();
                 CdmBase cb =  loadRecursive(cdmEntity, alreadyVisitedEntities, update);
                 alreadyVisitedEntities.clear();
                 logger.info("---- ending recursive load for cdm entity " + cdmEntity.getClass().getName() + " with id " + cdmEntity.getId() + "\n");
                 loadedCdmBase =  cb;
-...
         private CdmBase load(CdmBase cdmEntity) {
             logger.info("loading object of type " + cdmEntity.getClass().getName() + " with id " + cdmEntity.getId());
             cdmEntity = (CdmBase)ProxyUtils.deproxy(cdmEntity);
             // start by looking up the cdm entity in the cache
             CdmBase cachedCdmEntity = cdmCacher.getFromCache(cdmEntity);
-...
+            }
+        }
         private CdmBase loadRecursive(CdmBase cdmEntity,  Set<CdmBase> alreadyVisitedEntities) {
         private CdmBase loadRecursive(CdmBase cdmEntity,  Set<Object> alreadyVisitedEntities, boolean update) {
             CdmBase cachedCdmEntity = load(cdmEntity);
             if(cdmServiceCacher != null && cdmServiceCacher.exists(cachedCdmEntity)) {
                 return cachedCdmEntity;
+            }
             // we want to recursive through the cdmEntity (and not the cachedCdmEntity)
             // since there could be new or deleted objects in the cdmEntity sub-graph
-...
                     // this object will be either a CdmBase or a Collection / Map
                     // with CdmBase as the generic type
                     CdmBase cdmEntityInSubGraph = getCdmBaseTypeFieldValue(cdmEntity, cachedCdmEntity, field, alreadyVisitedEntities);
                     CdmBase cdmEntityInSubGraph = getCdmBaseTypeFieldValue(cdmEntity, cachedCdmEntity, field, alreadyVisitedEntities, update);
                     if(cdmEntityInSubGraph != null) {
                         //checkForIdenticalCdmEntity(alreadyVisitedEntities, cdmEntityInSubGraph);
                         if(!alreadyVisitedEntities.contains(cdmEntityInSubGraph)) {
                             logger.info("recursive loading object of type " + cdmEntityInSubGraph.getClass().getName() + " with id " + cdmEntityInSubGraph.getId());
                             loadRecursive(cdmEntityInSubGraph, alreadyVisitedEntities);
                             loadRecursive(cdmEntityInSubGraph, alreadyVisitedEntities, update);
                         } else {
                             logger.info("object of type " + cdmEntityInSubGraph.getClass().getName() + " with id " + cdmEntityInSubGraph.getId() + " already visited");
+                        }
-...
         private CdmBase getCdmBaseTypeFieldValue(CdmBase cdmEntity,
                 CdmBase cachedCdmEntity,
                 String fieldName,
                 Set<CdmBase> alreadyVisitedEntities) {
                 Set<Object> alreadyVisitedEntities,
                 boolean update) {
             // this method attempts to make sure that for any two objects found in
             // the object graph, if they are equal then they should also be the same,
-...
                 CdmBase cdmEntityInSubGraph = null;
                 if(update) {
                     // making sure that the field in cached cdm entity is always
                     // up-to-date by setting to the value of the cdm entity being loaded
                     // the only exception to this is found below
                     field.set(cachedCdmEntity, o);
+                }
                 if(o != null
                         && !ProxyFactory.isProxyClass(o.getClass())
                         && !(o instanceof PersistentCollection) ) {
                     if(CdmBase.class.isAssignableFrom(o.getClass())) {
                         logger.info("found initialised cdm entity '" + fieldName + "' in object of type " + clazz.getName() + " with id " + cdmEntity.getId());
                         cdmEntityInSubGraph  = (CdmBase)o;
                         CdmBase cachedCdmEntityInSubGraph = cdmCacher.getFromCache(cdmEntityInSubGraph);
                         // making sure that the field in cached cdm entity is always
                         // up-to-date by setting to the value of the cdm entity being loaded
                         // the only execption to this is found below
                         field.set(cachedCdmEntity, o);
                         // the only exception to updating the field to the latest value
                         // is the case where the field has been already initialised, cached and
-...
                                 logger.info("setting cached + real value to '" + fieldName + "' in object of type " + clazz.getName() + " with id " + cdmEntity.getId());
                                 field.set(cachedCdmEntity, cachedCdmEntityInSubGraph);
                                 field.set(cdmEntity, cachedCdmEntityInSubGraph);
                             } else {
                                 // hack to stop the recursion, since the field value object in cdmEntity
                                 // is the same as the field value object in cachedCdmEntity
                                 cdmEntityInSubGraph = null;
+                            }
                             cdmEntityInSubGraph = null;
+                        }
                     } else if(o instanceof Map) {
                         loadRecursive((Map)o, alreadyVisitedEntities);
                     } else if(o instanceof Collection) {
                         loadRecursive((Collection)o, alreadyVisitedEntities);
                     } else if(o instanceof Map && !alreadyVisitedEntities.contains(o)) {
                         loadRecursive((Map)o, alreadyVisitedEntities, update);
                     } else if(o instanceof Collection && !alreadyVisitedEntities.contains(o)) {
                         loadRecursive((Collection)o, alreadyVisitedEntities, update);
+                    }
+                }
                 // we return the original cdm entity in the sub graph because we
-...
             return false;
+        }
         public static boolean isRecursiveEnabled() {
             return isRecursiveEnabled;
+        }

Also available in: Unified diff

Project

General

Profile

EDIT

Revision 348d552a

Added by Cherian Mathew about 9 years ago