EDIT

package eu.etaxonomy.cdm.api.lazyloading;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TreeMap;

import java.util.TreeSet;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Pointcut;

import org.hibernate.collection.internal.PersistentList;

import org.hibernate.collection.internal.PersistentMap;

import org.hibernate.collection.internal.PersistentSet;

import org.hibernate.collection.internal.PersistentSortedMap;

import org.hibernate.collection.internal.PersistentSortedSet;

import org.hibernate.collection.spi.PersistentCollection;

import org.hibernate.proxy.LazyInitializer;

import org.springframework.beans.factory.annotation.Autowire;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Configurable;

import org.springframework.stereotype.Component;

import eu.etaxonomy.cdm.api.service.ICommonService;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.PersistentMultiLanguageText;

@Aspect

@Component

@Configurable(autowire = Autowire.BY_TYPE)

public class CdmLazyLoader {

	private final Set classes = new HashSet();

	public static boolean enableWeaving = true;

	private static Set<String> classesToIgnore = new HashSet<String>();

	@Autowired

	private ICommonService commonService;

	public CdmLazyLoader() {

		//classesToIgnore.add("eu.etaxonomy.cdm.model.common.TermVocabulary");

		//classesToIgnore.add("eu.etaxonomy.cdm.model.common.OrderedTermVocabulary");

	}

	/**

	 *  Point cut for the 'initialize' method of the AbstractLazyInitializer.

	 *

	 */

	@Pointcut("execution(* org.hibernate.proxy.AbstractLazyInitializer.initialize())")

	public void possibleEntityLazyInitializationException() {

	}

	/**

	 *  'Around' advice for the initialization of CDM Entity Objects

	 *

	 */

	@Around(value = "possibleEntityLazyInitializationException()")

	public Object preloadEntityOnDemand(ProceedingJoinPoint pjp) throws Throwable {

		if(enableWeaving) {

			LazyInitializer ll = (LazyInitializer)pjp.getTarget();

			if(ll.isUninitialized()) {

				int classid = ((Integer)ll.getIdentifier()).intValue();

				System.out.print("--> AspectJ Compile-Time Weaving " + ll.getEntityName() + " with id " + classid);

				Class clazz = Class.forName(ll.getEntityName());

				CdmBase cdmBase = CdmBase.deproxy(commonService.find(clazz,classid),clazz);

				ll.setImplementation(cdmBase);

				System.out.println("....Done");

			}

		}

		return pjp.proceed();

	}

	/**

	 *  Point cut for the 'initialize' method of the AbstractPersistentCollection.

	 *

	 */

	@Pointcut("execution(protected final void org.hibernate.collection.internal.AbstractPersistentCollection.initialize(..))")

	public void possibleCollectionLazyInitializationException() {

	}

	/**

	 *  'Around' advice for the initialization of Collection objects

	 *

	 */

	@Around(value = "possibleCollectionLazyInitializationException()")

	public Object preloadCollectionOnDemand(ProceedingJoinPoint pjp) throws Throwable {

		if(enableWeaving) {

			PersistentCollection ps = (PersistentCollection) pjp.getTarget();

			if (ps.getOwner() != null && !classesToIgnore.contains(ps.getOwner().getClass().getName()) && !ps.wasInitialized() &&  !classes.contains(ps.getKey())) {

				System.out.print("--> AspectJCompile-Time Weaving " + ps.getRole());

				classes.add(ps.getKey());

				try {

					String role = ps.getRole();

					String fieldName = role.substring(role.lastIndexOf(".") + 1);

					System.out.print(", field : " + fieldName);

					Object owner = ps.getOwner();

					Object col = commonService.initializeCollection(((CdmBase)owner).getUuid(), fieldName);

					ps.afterInitialize();

//					Class<?> clazz = ps.getClass();

//					if (clazz != null) {

//						CollectionField cf = getCollectionField(col);

//						Field field = clazz.getDeclaredField(cf.getFieldName());

//						field.setAccessible(true);

//						field.set(ps, cf.getCollection());

//					}

				} catch (Exception ex) {

					ex.printStackTrace();

					System.out.println("Error in ReattachSessionAspect : " + ex.getMessage());

				} finally {

					classes.remove(ps.getKey());

					System.out.println("....Done");

					throw new Exception("This code is invalid");

				}

			}

		}

		return pjp.proceed();

	}

	private CollectionField getCollectionField(PersistentCollection pc) {

		if(pc != null) {

			if(pc instanceof PersistentSet) {

				return new CollectionField(new HashSet((Set)pc), "set");

			}

			if(pc instanceof PersistentSortedSet) {

				return new CollectionField(new TreeSet((Set)pc), "set");

			}

			if(pc instanceof PersistentList) {

				return new CollectionField(new ArrayList((List)pc), "list");

			}

			if(pc instanceof PersistentMap || pc instanceof PersistentMultiLanguageText) {

				return new CollectionField(new HashMap((Map)pc), "map");

			}

			if(pc instanceof PersistentSortedMap) {

				return new CollectionField(new TreeMap((Map)pc), "map");

			}

		}

		return null;

	}

	private String getCollectionFieldName(PersistentCollection pc) {

		if(pc != null) {

			if(pc instanceof PersistentSet || pc instanceof PersistentSortedSet) {

				return "set";

			}

			if(pc instanceof PersistentList) {

				return "list";

			}

			if(pc instanceof PersistentMap || pc instanceof PersistentMultiLanguageText) {

				return "map";

			}

		}

		return null;

	}

	private class CollectionField {

		private final Object col;

		private final String fieldName;

		public CollectionField(Object col, String fieldName) {

			this.col = col;

			this.fieldName = fieldName;

		}

		public Object getCollection() {

			return this.col;

		}

		public String getFieldName() {

			return this.fieldName;

		}

	}

}