EDIT

package eu.etaxonomy.cdm.api.lazyloading;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

public class CdmLazyLoader {

	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()")

		if(enableWeaving) {

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

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

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

				ll.setImplementation(cdmBase);

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

			}

		}

	}

	/**

	 *  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

	 */

		if(enableWeaving) {

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

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

				classes.add(ps.getKey());

				try {

					String role = ps.getRole();

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

					Object owner = ps.getOwner();

					ps.afterInitialize();

				} catch (Exception ex) {

					ex.printStackTrace();

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

				} finally {

					classes.remove(ps.getKey());

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

			}

		return pjp.proceed();

	}

	private CollectionField getCollectionField(PersistentCollection pc) {

		if(pc != null) {

			if(pc instanceof PersistentSet) {

		}

		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";

			}

		}

		return null;

	}

	private class CollectionField {

		public CollectionField(Object col, String fieldName) {

			this.col = col;

			this.fieldName = fieldName;

		}

		public Object getCollection() {

			return this.col;

		}

		public String getFieldName() {

			return this.fieldName;

		}

package org.hibernate.collection.internal;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

	private static final Logger log = Logger.getLogger( AbstractPersistentCollection.class );

	private static final long serialVersionUID = -7238232378593030571L;

	private transient SessionImplementor session;

	private boolean initialized;

	private transient List<DelayedOperation> operationQueue;

	private String sessionFactoryUuid;

	private boolean specjLazyLoad = false;

		return role;

	}

		return key;

	}

		return role == null;

	}

		return dirty;

	}

		dirty = false;

	}

		dirty = true;

	}

		return storedSnapshot;

	}

	/**

	 * Is the initialized collection empty?

	 */

	/**

	 * Called by any read-only method of the collection interface

			else {

				// In remoting we are sure that session is null

				// both when using property paths and switching off conversations

					log.info("--> readSize, of " + getRole() + " with key " + getKey());

				} else {

					boolean isExtraLazy = withTemporarySessionIfNeeded(

							new LazyInitializationWork<Boolean>() {

					.getTransactionContext().getTransactionEnvironment()

					.getTransactionFactory()

					.compatibleWithJtaSynchronization();

			if ( !isJTA ) {

				// Explicitly handle the transactions only if we're not in

				// a JTA environment.  A lazy loading temporary session can

				// multiple transactions.

				( ( Session) session ).beginTransaction();

			}

			session.getPersistenceContext().addUninitializedDetachedCollection(

					session.getFactory().getCollectionPersister( getRole() ),

					this

		if ( !initialized ) {

			// In remoting we are sure that session is null

			// both when using property paths and switching off conversations

				log.info("--> readIndexExistence, of " + getRole() + " with key " + getKey());

			} else {

				Boolean extraLazyExistenceCheck = withTemporarySessionIfNeeded(

						new LazyInitializationWork<Boolean>() {

			// both when using property paths and switching off conversations

			if(session == null && remoting) {

				log.info("--> readElementExistence, of " + getRole() + " with key " + getKey());

			} else {

				Boolean extraLazyExistenceCheck = withTemporarySessionIfNeeded(

						new LazyInitializationWork<Boolean>() {

		if ( !initialized ) {

			// In remoting we are sure that session is null

			// both when using property paths and switching off conversations

				log.info("--> readElementByIndex, of " + getRole() + " with key " + getKey());

			} else {

				class ExtraLazyElementByIndexReader implements LazyInitializationWork {

					private boolean isExtraLazy;

	/**

	 * After flushing, re-init snapshot state.

	 */

		this.key = key;

		this.role = role;

		this.storedSnapshot = snapshot;

	 * After flushing, clear any "queued" additions, since the

	 * database state is now synchronized with the memory state.

	 */

		operationQueue = null;

		cachedSize = -1;

		clearDirty();

	/**

	 * return the user-visible collection (or array) instance

	 */

		return this;

	}

	/**

	 * Called just before reading any rows from the JDBC result set

	 */

		// override on some subclasses

		initializing = true;

	}

	/**

	 * Called after reading all rows from the JDBC result set

	 */

		//override on some subclasses

		return afterInitialize();

	}

		setInitialized();

		//do this bit after setting initialized to true or it will recurse

		if ( operationQueue != null ) {

		// In remoting we are sure that session is null

		// both when using property paths and switching off conversations

		if(session == null && remoting) {

		}

		if ( initialized ) {

			return;

		}

		withTemporarySessionIfNeeded(

				new LazyInitializationWork<Object>() {

					@Override

	 * Could the application possibly have a direct reference to

	 * the underlying collection implementation?

	 */

		return directlyAccessible;

	}

	 *

	 * @return true if this was currently associated with the given session

	 */

		prepareForPossibleSpecialSpecjInitialization();

		if ( currentSession == this.session ) {

			this.session = null;

	 * @throws HibernateException if the collection was already associated

	 * with another open session

	 */

		if ( session == this.session ) {

			return false;

		}

	/**

	 * Do we need to completely recreate this collection when it changes?

	 */

		return false;

	}

	 * To be called internally by the session, forcing

	 * immediate initialization.

	 */

		if ( !initialized ) {

			if ( initializing ) {

				throw new AssertionFailure( "force initialize loading collection" );

	/**

	 * Is this instance initialized?

	 */

		return initialized;

	}

		return true;

	}

	/**

	 * Does this instance have any "queued" additions?

	 */

		return operationQueue != null;

	}

	/**

	 * Iterate the "queued" additions

	 */

		if ( hasQueuedOperations() ) {

			return new Iterator() {

				int i = 0;

					return operationQueue.get( i++ ).getAddedInstance();

				}

					return i < operationQueue.size();

				}

					throw new UnsupportedOperationException();

				}

			};

	/**

	 * Iterate the "queued" additions

	 */

	public final Collection getQueuedOrphans(String entityName) {

		if ( hasQueuedOperations() ) {

			Collection additions = new ArrayList( operationQueue.size() );

	 * Called before inserting rows, to ensure that any surrogate keys

	 * are fully generated

	 */

	}

	/**

	 * Called after inserting a row, to fetch the natively generated id

	 */

	}

	/**

	 * get all "orphaned" elements

	 */

	/**

	 * Get the current session

			this.itr = itr;

		}

			return itr.hasNext();

		}

			return itr.next();

		}

			write();

			itr.remove();

		}

			this.itr = itr;

		}

		public void add(Object o) {

			write();

			itr.add( o );

		}

			return itr.hasNext();

		}

			return itr.hasPrevious();

		}

			return itr.next();

		}

			return itr.nextIndex();

		}

			return itr.previous();

		}

			return itr.previousIndex();

		}

			write();

			itr.remove();

		}

		public void set(Object o) {

			write();

			itr.set( o );

			this.set = set;

		}

		public boolean add(Object o) {

			write();

			return set.add( o );

		}

		public boolean addAll(Collection c) {

			write();

			return set.addAll( c );

		}

			write();

			set.clear();

		}

			return set.contains( o );

		}

			return set.containsAll( c );

		}

			return set.isEmpty();

		}

			return new IteratorProxy( set.iterator() );

		}

			write();

			return set.remove( o );

		}

			write();

			return set.removeAll( c );

		}

			write();

			return set.retainAll( c );

		}

			return set.size();

		}

			return set.toArray();

		}

		public Object[] toArray(Object[] array) {

			return set.toArray( array );

		}

		}

	}

		throw new UnsupportedOperationException();

	}

		return owner;

	}

		this.owner = owner;

	}

	/** ------ Below is section of code which makes remote service calls ----- */

	// initialize(final boolean writing)

	// readSize()

	// readIndexExistence(final Object index)

	// readElementExistence(final Object element)

	private static ICdmApplicationConfiguration configuration;

	private static boolean remoting = false;

	public static void setConfiguration(ICdmApplicationConfiguration conf) {

		configuration = conf;

		if(conf instanceof CdmApplicationRemoteController) {

			remoting = true;

		} else {

			remoting = false;

		}

	}

	private void remoteInitialize() {

			try {

				String role = getRole();

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

				log.info("--> Remote Lazy Initializing " + getRole() + " , key : " + getKey() + " , field : " + fieldName);

				Object owner = getOwner();

				if(configuration == null) {

					throw new HibernateException("CdmApplicationRemoteConfiguration not initialized (null)");

				}

				if(commonService == null) {

					throw new HibernateException("commonService not initialized (null)");

				}

			} catch (Exception ex) {

				log.warn(ex.getMessage());

		}

	}

	private CollectionField getCollectionField(PersistentCollection pc) {

		if(pc != null) {

			if(pc instanceof PersistentSet) {

		}

		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";

			}

		}

		return null;

	}

	private class CollectionField {

		public CollectionField(Object col, String fieldName) {

			this.col = col;

			this.fieldName = fieldName;

		}

		public Object getCollection() {

			return this.col;

		}

		public String getFieldName() {

			return this.fieldName;

		}

	}

	public static boolean isInitialized(List list) {

		return ((AbstractPersistentCollection)list).initialized;

	}

	public static boolean isInitialized(Map map) {

		return ((AbstractPersistentCollection)map).initialized;

	}

	public static boolean isInitialized(Set set) {

		return ((AbstractPersistentCollection)set).initialized;

	}

}