Java EntityPersister.createProxy方法代码示例

import org.hibernate.persister.entity.EntityPersister; //导入方法依赖的package包/类
@Override
public Object internalLoad(
		String entityName,
        Serializable id,
        boolean eager,
        boolean nullable) throws HibernateException {
	errorIfClosed();
	EntityPersister persister = getFactory().getEntityPersister( entityName );
	// first, try to load it from the temp PC associated to this SS
	Object loaded = temporaryPersistenceContext.getEntity( generateEntityKey( id, persister ) );
	if ( loaded != null ) {
		// we found it in the temp PC.  Should indicate we are in the midst of processing a result set
		// containing eager fetches via join fetch
		return loaded;
	}
	if ( !eager && persister.hasProxy() ) {
		// if the metadata allowed proxy creation and caller did not request forceful eager loading,
		// generate a proxy
		return persister.createProxy( id, this );
	}
	// otherwise immediately materialize it
	return get( entityName, id );
}
 

import org.hibernate.persister.entity.EntityPersister; //导入方法依赖的package包/类
/**
 * If there is already a corresponding proxy associated with the
 * persistence context, return it; otherwise create a proxy, associate it
 * with the persistence context, and return the just-created proxy.
 *
 * @param event The initiating load request event
 * @param persister The persister corresponding to the entity to be loaded
 * @param keyToLoad The key of the entity to be loaded
 * @param options The defined load options
 * @param persistenceContext The originating session
 *
 * @return The created/existing proxy
 */
private Object createProxyIfNecessary(
		final LoadEvent event,
		final EntityPersister persister,
		final EntityKey keyToLoad,
		final LoadEventListener.LoadType options,
		final PersistenceContext persistenceContext) {
	Object existing = persistenceContext.getEntity( keyToLoad );
	if ( existing != null ) {
		// return existing object or initialized proxy (unless deleted)
		LOG.trace( "Entity found in session cache" );
		if ( options.isCheckDeleted() ) {
			EntityEntry entry = persistenceContext.getEntry( existing );
			Status status = entry.getStatus();
			if ( status == Status.DELETED || status == Status.GONE ) {
				return null;
			}
		}
		return existing;
	}
	LOG.trace( "Creating new proxy for entity" );
	// return new uninitialized proxy
	Object proxy = persister.createProxy( event.getEntityId(), event.getSession() );
	persistenceContext.getBatchFetchQueue().addBatchLoadableEntityKey( keyToLoad );
	persistenceContext.addProxy( keyToLoad, proxy );
	return proxy;
}
 

import org.hibernate.persister.entity.EntityPersister; //导入方法依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public Object narrowProxy(Object proxy, EntityPersister persister, EntityKey key, Object object)
		throws HibernateException {

	final Class concreteProxyClass = persister.getConcreteProxyClass();
	final boolean alreadyNarrow = concreteProxyClass.isInstance( proxy );

	if ( !alreadyNarrow ) {
		LOG.narrowingProxy( concreteProxyClass );

		// If an impl is passed, there is really no point in creating a proxy.
		// It would just be extra processing.  Just return the impl
		if ( object != null ) {
			proxiesByKey.remove( key );
			return object;
		}

		// Similarly, if the original HibernateProxy is initialized, there
		// is again no point in creating a proxy.  Just return the impl
		final HibernateProxy originalHibernateProxy = (HibernateProxy) proxy;
		if ( !originalHibernateProxy.getHibernateLazyInitializer().isUninitialized() ) {
			final Object impl = originalHibernateProxy.getHibernateLazyInitializer().getImplementation();
			// can we return it?
			if ( concreteProxyClass.isInstance( impl ) ) {
				proxiesByKey.remove( key );
				return impl;
			}
		}


		// Otherwise, create the narrowed proxy
		final HibernateProxy narrowedProxy = (HibernateProxy) persister.createProxy( key.getIdentifier(), session );

		// set the read-only/modifiable mode in the new proxy to what it was in the original proxy
		final boolean readOnlyOrig = originalHibernateProxy.getHibernateLazyInitializer().isReadOnly();
		narrowedProxy.getHibernateLazyInitializer().setReadOnly( readOnlyOrig );

		return narrowedProxy;
	}
	else {

		if ( object != null ) {
			final LazyInitializer li = ( (HibernateProxy) proxy ).getHibernateLazyInitializer();
			li.setImplementation( object );
		}
		return proxy;
	}
}