org.hibernate.engine.SessionImplementor#getEntityUsingInterceptor ( )源码实例Demo

/**
 * Attempts to locate the entity in the session-level cache.
 * <p/>
 * If allowed to return nulls, then if the entity happens to be found in
 * the session cache, we check the entity type for proper handling
 * of entity hierarchies.
 * <p/>
 * If checkDeleted was set to true, then if the entity is found in the
 * session-level cache, it's current status within the session cache
 * is checked to see if it has previously been scheduled for deletion.
 *
 * @param event The load event
 * @param keyToLoad The EntityKey representing the entity to be loaded.
 * @param options The load options.
 * @return The entity from the session-level cache, or null.
 * @throws HibernateException Generally indicates problems applying a lock-mode.
 */
protected Object loadFromSessionCache(
		final LoadEvent event,
		final EntityKey keyToLoad,
		final LoadEventListener.LoadType options) throws HibernateException {
	
	SessionImplementor session = event.getSession();
	Object old = session.getEntityUsingInterceptor( keyToLoad );

	if ( old != null ) {
		// this object was already loaded
		EntityEntry oldEntry = session.getPersistenceContext().getEntry( old );
		if ( options.isCheckDeleted() ) {
			Status status = oldEntry.getStatus();
			if ( status == Status.DELETED || status == Status.GONE ) {
				return REMOVED_ENTITY_MARKER;
			}
		}
		if ( options.isAllowNulls() ) {
			EntityPersister persister = event.getSession().getFactory().getEntityPersister( event.getEntityClassName() );
			if ( ! persister.isInstance( old, event.getSession().getEntityMode() ) ) {
				return INCONSISTENT_RTN_CLASS_MARKER;
			}
		}
		upgradeLock( old, oldEntry, event.getLockMode(), session );
	}

	return old;
}
 

/**
 * Resolve any ids for currently loaded objects, duplications within the
 * <tt>ResultSet</tt>, etc. Instantiate empty objects to be initialized from the
 * <tt>ResultSet</tt>. Return an array of objects (a row of results) and an
 * array of booleans (by side-effect) that determine whether the corresponding
 * object should be initialized.
 */
private Object[] getRow(
        final ResultSet rs,
        final Loadable[] persisters,
        final EntityKey[] keys,
        final Object optionalObject,
        final EntityKey optionalObjectKey,
        final LockMode[] lockModes,
        final List hydratedObjects,
        final SessionImplementor session) 
throws HibernateException, SQLException {

	final int cols = persisters.length;
	final EntityAliases[] descriptors = getEntityAliases();

	if ( log.isDebugEnabled() ) {
		log.debug( 
				"result row: " + 
				StringHelper.toString( keys ) 
			);
	}

	final Object[] rowResults = new Object[cols];

	for ( int i = 0; i < cols; i++ ) {

		Object object = null;
		EntityKey key = keys[i];

		if ( keys[i] == null ) {
			//do nothing
		}
		else {

			//If the object is already loaded, return the loaded one
			object = session.getEntityUsingInterceptor( key );
			if ( object != null ) {
				//its already loaded so don't need to hydrate it
				instanceAlreadyLoaded( 
						rs,
						i,
						persisters[i],
						key,
						object,
						lockModes[i],
						session 
					);
			}
			else {
				object = instanceNotYetLoaded( 
						rs,
						i,
						persisters[i],
						descriptors[i].getRowIdAlias(),
						key,
						lockModes[i],
						optionalObjectKey,
						optionalObject,
						hydratedObjects,
						session 
					);
			}

		}

		rowResults[i] = object;

	}

	return rowResults;
}