Refine search
@Override public Object unproxy(Object maybeProxy) throws HibernateException { if ( maybeProxy instanceof HibernateProxy ) { final HibernateProxy proxy = (HibernateProxy) maybeProxy; final LazyInitializer li = proxy.getHibernateLazyInitializer(); if ( li.isUninitialized() ) { throw new PersistentObjectException( "object was an uninitialized proxy for " + li.getEntityName() ); } //unwrap the object and return return li.getImplementation(); } else { return maybeProxy; } }
/** * Associate a proxy that was instantiated by another session with this session * * @param li The proxy initializer. * @param proxy The proxy to reassociate. */ private void reassociateProxy(LazyInitializer li, HibernateProxy proxy) { if ( li.getSession() != this.getSession() ) { final EntityPersister persister = session.getFactory().getMetamodel().entityPersister( li.getEntityName() ); final EntityKey key = session.generateEntityKey( li.getIdentifier(), persister ); // any earlier proxy takes precedence proxiesByKey.putIfAbsent( key, proxy ); proxy.getHibernateLazyInitializer().setSession( session ); } }
/** * Get the class of an instance or the underlying class * of a proxy (without initializing the proxy!). It is * almost always better to use the entity name! */ public static Class getClassWithoutInitializingProxy(Object object) { if (object instanceof HibernateProxy) { HibernateProxy proxy = (HibernateProxy) object; LazyInitializer li = proxy.getHibernateLazyInitializer(); return li.getPersistentClass(); } else { return object.getClass(); } }
private void setProxyReadOnly(HibernateProxy proxy, boolean readOnly) { if ( proxy.getHibernateLazyInitializer().getSession() != getSession() ) { throw new AssertionFailure( "Attempt to set a proxy to read-only that is associated with a different session" ); } proxy.getHibernateLazyInitializer().setReadOnly( readOnly ); }
public boolean contains(Object collection, Object childObject, SharedSessionContractImplementor session) { // we do not have to worry about queued additions to uninitialized // collections, since they can only occur for inverse collections! Iterator elems = getElementsIterator( collection, session ); while ( elems.hasNext() ) { Object element = elems.next(); // worrying about proxies is perhaps a little bit of overkill here... if ( element instanceof HibernateProxy ) { LazyInitializer li = ( (HibernateProxy) element ).getHibernateLazyInitializer(); if ( !li.isUninitialized() ) { element = li.getImplementation(); } } if ( element == childObject ) { return true; } } return false; }
@Override public <T> T unenhanceObject(T object) { if (object instanceof HibernateProxy) { HibernateProxy hibernateProxy = (HibernateProxy)object; LazyInitializer lazyInitializer = hibernateProxy.getHibernateLazyInitializer(); return (T)lazyInitializer.getImplementation(); } return object; }
LazyInitializer li = ( (HibernateProxy) object ).getHibernateLazyInitializer(); if ( li.isUninitialized() ) { return li.getSession() == this; object = li.getImplementation();
@Override public String getEntityName(Object object) { checkOpen(); // checkTransactionSynchStatus(); if ( object instanceof HibernateProxy ) { if ( !persistenceContext.containsProxy( object ) ) { throw new TransientObjectException( "proxy was not associated with the session" ); } object = ( (HibernateProxy) object ).getHibernateLazyInitializer().getImplementation(); } EntityEntry entry = persistenceContext.getEntry( object ); if ( entry == null ) { throwTransientObjectException( object ); } return entry.getPersister().getEntityName(); }
public static Object getTargetFromProxy(SessionFactoryImplementor sessionFactoryImplementor, HibernateProxy proxy) { if ( !proxy.getHibernateLazyInitializer().isUninitialized() || activeProxySession( proxy ) ) { return proxy.getHibernateLazyInitializer().getImplementation(); } final SharedSessionContractImplementor sessionImplementor = proxy.getHibernateLazyInitializer().getSession(); final Session tempSession = sessionImplementor == null ? sessionFactoryImplementor.openTemporarySession() : sessionImplementor.getFactory().openTemporarySession(); try { return tempSession.get( proxy.getHibernateLazyInitializer().getEntityName(), proxy.getHibernateLazyInitializer().getIdentifier() ); } finally { tempSession.close(); } }
private Serializable getProxyIdentifier(Object proxy) { return ( (HibernateProxy) proxy ).getHibernateLazyInitializer().getIdentifier(); }
/** * Force initialization of a proxy or persistent collection. * <p/> * Note: This only ensures intialization of a proxy object or collection; * it is not guaranteed that the elements INSIDE the collection will be initialized/materialized. * * @param proxy a persistable object, proxy, persistent collection or <tt>null</tt> * @throws HibernateException if we can't initialize the proxy at this time, eg. the <tt>Session</tt> was closed */ public static void initialize(Object proxy) throws HibernateException { if ( proxy == null ) { return; } if ( proxy instanceof HibernateProxy ) { ( (HibernateProxy) proxy ).getHibernateLazyInitializer().initialize(); } else if ( proxy instanceof PersistentCollection ) { ( (PersistentCollection) proxy ).forceInitialization(); } }
throws HibernateException { final Class concreteProxyClass = persister.getConcreteProxyClass(); final boolean alreadyNarrow = concreteProxyClass.isInstance( proxy ); if ( !originalHibernateProxy.getHibernateLazyInitializer().isUninitialized() ) { final Object impl = originalHibernateProxy.getHibernateLazyInitializer().getImplementation(); final HibernateProxy narrowedProxy = (HibernateProxy) persister.createProxy( key.getIdentifier(), session ); final boolean readOnlyOrig = originalHibernateProxy.getHibernateLazyInitializer().isReadOnly(); narrowedProxy.getHibernateLazyInitializer().setReadOnly( readOnlyOrig ); final LazyInitializer li = ( (HibernateProxy) proxy ).getHibernateLazyInitializer(); li.setImplementation( object );
public Object unwrapProxy(final HibernateProxy proxy) { final LazyInitializer lazyInitializer = proxy.getHibernateLazyInitializer(); if (lazyInitializer.isUninitialized()) { lazyInitializer.initialize(); } final Object obj = lazyInitializer.getImplementation(); if (obj != null) { ensureCorrectGroovyMetaClass(obj, obj.getClass()); } return obj; }
LazyInitializer li = ( (HibernateProxy) original ).getHibernateLazyInitializer(); if ( li.isUninitialized() ) { LOG.trace( "Ignoring uninitialized proxy" ); event.setResult( source.load( li.getEntityName(), li.getIdentifier() ) ); return; //EARLY EXIT! entity = li.getImplementation(); if ( entry == null ) { EntityPersister persister = source.getEntityPersister( event.getEntityName(), entity ); Serializable id = persister.getIdentifier( entity, source ); if ( id != null ) { final EntityKey key = source.generateEntityKey( id, persister );
LazyInitializer li = ( (HibernateProxy) object ).getHibernateLazyInitializer(); if ( li.isUninitialized() ) { if ( li.getSession() == source ) { return; //NOTE EARLY EXIT! entity = li.getImplementation(); if ( ForeignGenerator.class.isInstance( persister.getIdentifierGenerator() ) ) { if ( LOG.isDebugEnabled() && persister.getIdentifier( entity, source ) != null ) { LOG.debug( "Resetting entity id attribute to null for foreign generator" ); persister.setIdentifier( entity, null, source ); entityState = getEntityState( entity, entityName, entityEntry, source );
@Override public int getHashCode(Object x, SessionFactoryImplementor factory) { EntityPersister persister = getAssociatedEntityPersister( factory ); if ( !persister.canExtractIdOutOfEntity() ) { return super.getHashCode( x ); } final Serializable id; if ( x instanceof HibernateProxy ) { id = ( (HibernateProxy) x ).getHibernateLazyInitializer().getIdentifier(); } else { final Class mappedClass = persister.getMappedClass(); if ( mappedClass.isAssignableFrom( x.getClass() ) ) { id = persister.getIdentifier( x ); } else { id = (Serializable) x; } } return persister.getIdentifierType().getHashCode( id, factory ); }
if ( !persister.getEntityTuplizer().isInstance( value ) ) { if ( persister.getIdentifierType().getReturnedClass().isInstance( value ) ) { return associatedEntityName + "#" + value; if ( persister.hasIdentifierProperty() ) { final Serializable id; if ( value instanceof HibernateProxy ) { HibernateProxy proxy = (HibernateProxy) value; id = proxy.getHibernateLazyInitializer().getIdentifier();
LOG.trace( "Entity proxy found in session cache" ); LazyInitializer li = ( (HibernateProxy) proxy ).getHibernateLazyInitializer(); if ( li.isUnwrap() ) { return li.getImplementation(); .getFactory() .getEntityNotFoundDelegate() .handleEntityNotFound( persister.getEntityName(), keyToLoad.getIdentifier() );
/** * Check if the proxy or persistent collection is initialized. * * @param proxy a persistable object, proxy, persistent collection or <tt>null</tt> * @return true if the argument is already initialized, or is not a proxy or collection */ @SuppressWarnings("SimplifiableIfStatement") public static boolean isInitialized(Object proxy) { if ( proxy instanceof HibernateProxy ) { return !( (HibernateProxy) proxy ).getHibernateLazyInitializer().isUninitialized(); } else if ( proxy instanceof PersistentCollection ) { return ( (PersistentCollection) proxy ).wasInitialized(); } else { return true; } }
public static Object getIdentifier(SessionImplementor session, String entityName, Object obj) { if ( obj == null ) { return null; } if ( obj instanceof HibernateProxy ) { final HibernateProxy hibernateProxy = (HibernateProxy) obj; return hibernateProxy.getHibernateLazyInitializer().getIdentifier(); } return session.getEntityPersister( entityName, obj ).getIdentifier( obj, session ); }