/** * 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 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 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; } }
final boolean isInitialized = !( (HibernateProxy) reference ).getHibernateLazyInitializer().isUninitialized(); return isInitialized ? LoadState.LOADED : LoadState.NOT_LOADED;
/** * Check if the property is initialized. If the named property does not exist * or is not persistent, this method always returns <tt>true</tt>. * * @param proxy The potential proxy * @param propertyName the name of a persistent attribute of the object * @return true if the named property of the object is not listed as uninitialized; false otherwise */ public static boolean isPropertyInitialized(Object proxy, String propertyName) { final Object entity; if ( proxy instanceof HibernateProxy ) { final LazyInitializer li = ( (HibernateProxy) proxy ).getHibernateLazyInitializer(); if ( li.isUninitialized() ) { return false; } else { entity = li.getImplementation(); } } else { entity = proxy; } if ( entity instanceof PersistentAttributeInterceptable ) { PersistentAttributeInterceptor interceptor = ( (PersistentAttributeInterceptable) entity ).$$_hibernate_getInterceptor(); if ( interceptor != null && interceptor instanceof LazyAttributeLoadingInterceptor ) { return ( (LazyAttributeLoadingInterceptor) interceptor ).isAttributeLoaded( propertyName ); } } return true; }
if ( entity instanceof HibernateProxy ) { final LazyInitializer li = ( (HibernateProxy) entity ).getHibernateLazyInitializer(); if ( li.isUninitialized() ) {
if ( !originalHibernateProxy.getHibernateLazyInitializer().isUninitialized() ) { final Object impl = originalHibernateProxy.getHibernateLazyInitializer().getImplementation();
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(); } }
@Override public String bestGuessEntityName(Object object) { if ( object instanceof HibernateProxy ) { LazyInitializer initializer = ( (HibernateProxy) object ).getHibernateLazyInitializer(); // it is possible for this method to be called during flush processing, // so make certain that we do not accidentally initialize an uninitialized proxy if ( initializer.isUninitialized() ) { return initializer.getEntityName(); } object = initializer.getImplementation(); } EntityEntry entry = persistenceContext.getEntry( object ); if ( entry == null ) { return guessEntityName( object ); } else { return entry.getPersister().getEntityName(); } }
private EntityPersister guessEntityPersister(Object object) { if ( scope == null ) { return null; } String entityName = null; // this code is largely copied from Session's bestGuessEntityName Object entity = object; if ( entity instanceof HibernateProxy ) { final LazyInitializer initializer = ( (HibernateProxy) entity ).getHibernateLazyInitializer(); if ( initializer.isUninitialized() ) { entityName = initializer.getEntityName(); } entity = initializer.getImplementation(); } if ( entityName == null ) { for ( EntityNameResolver resolver : scope.getTypeConfiguration().getSessionFactory().getMetamodel().getEntityNameResolvers() ) { entityName = resolver.resolveEntityName( entity ); if ( entityName != null ) { break; } } } if ( entityName == null ) { // the old-time stand-by... entityName = object.getClass().getName(); } return scope.getTypeConfiguration().getSessionFactory().getMetamodel().entityPersister( entityName ); }
if ( li.isUninitialized() ) {
@Test public void testModifiableViaLazyInitializerAfterInit() { DataPoint dpOrig = createDataPoint( CacheMode.IGNORE ); Session s = openSession(); s.setCacheMode(CacheMode.IGNORE); s.beginTransaction(); DataPoint dp = ( DataPoint ) s.load( DataPoint.class, new Long( dpOrig.getId() ) ); assertTrue( dp instanceof HibernateProxy ); LazyInitializer dpLI = ( ( HibernateProxy ) dp ).getHibernateLazyInitializer(); assertTrue( dpLI.isUninitialized() ); checkReadOnly( s, dp, false ); dp.setDescription( "changed" ); assertFalse( dpLI.isUninitialized() ); assertEquals( "changed", dp.getDescription() ); checkReadOnly( s, dp, false ); s.flush(); s.getTransaction().commit(); s.close(); s = openSession(); s.beginTransaction(); dp = ( DataPoint ) s.get( DataPoint.class, dpOrig.getId() ); assertEquals( dpOrig.getId(), dp.getId() ); assertEquals( "changed", dp.getDescription() ); assertEquals( dpOrig.getX(), dp.getX() ); assertEquals( dpOrig.getY(), dp.getY() ); s.delete( dp ); s.getTransaction().commit(); s.close(); }
@Test public void testModifiableViaLazyInitializerBeforeInit() { DataPoint dpOrig = createDataPoint( CacheMode.IGNORE ); Session s = openSession(); s.setCacheMode(CacheMode.IGNORE); s.beginTransaction(); DataPoint dp = ( DataPoint ) s.load( DataPoint.class, new Long( dpOrig.getId() ) ); assertTrue( dp instanceof HibernateProxy ); LazyInitializer dpLI = ( ( HibernateProxy ) dp ).getHibernateLazyInitializer(); assertTrue( dp instanceof HibernateProxy ); assertTrue( dpLI.isUninitialized() ); checkReadOnly( s, dp, false ); dp.setDescription( "changed" ); assertFalse( dpLI.isUninitialized() ); assertEquals( "changed", dp.getDescription() ); checkReadOnly( s, dp, false ); s.flush(); s.getTransaction().commit(); s.close(); s = openSession(); s.beginTransaction(); dp = ( DataPoint ) s.get( DataPoint.class, dpOrig.getId() ); assertEquals( dpOrig.getId(), dp.getId() ); assertEquals( "changed", dp.getDescription() ); assertEquals( dpOrig.getX(), dp.getX() ); assertEquals( dpOrig.getY(), dp.getY() ); s.delete( dp ); s.getTransaction().commit(); s.close(); }
LazyInitializer dpLI = ( ( HibernateProxy ) dp ).getHibernateLazyInitializer(); checkReadOnly( s, dp, false ); assertTrue( dpLI.isUninitialized() ); Hibernate.initialize( dp ); assertFalse( dpLI.isUninitialized() ); checkReadOnly( s, dp, false ); s.getTransaction().commit(); dpLI.setReadOnly( true ); checkReadOnly( s, dp, true ); assertTrue( dpLI.isUninitialized() ); Hibernate.initialize( dp ); assertFalse( dpLI.isUninitialized() ); checkReadOnly( s, dp, true ); s.getTransaction().commit(); dpLI.setReadOnly( true ); checkReadOnly( s, dp, true ); assertTrue( dpLI.isUninitialized() ); dpLI.setReadOnly( false ); checkReadOnly( s, dp, false ); assertTrue( dpLI.isUninitialized() ); Hibernate.initialize( dp ); assertFalse( dpLI.isUninitialized() ); checkReadOnly( s, dp, false ); s.getTransaction().commit();
public void unScheduleDeletion(EntityEntry entry, Object rescuedEntity) { if ( rescuedEntity instanceof HibernateProxy ) { LazyInitializer initializer = ( (HibernateProxy) rescuedEntity ).getHibernateLazyInitializer(); if ( !initializer.isUninitialized() ) { rescuedEntity = initializer.getImplementation( session ); } } if( deletions != null ) { for ( int i = 0; i < deletions.size(); i++ ) { EntityDeleteAction action = deletions.get( i ); if (action.getInstance() == rescuedEntity) { deletions.remove( i ); return; } } } if( orphanRemovals != null ) { for ( int i = 0; i < orphanRemovals.size(); i++ ) { EntityDeleteAction action = orphanRemovals.get( i ); if (action.getInstance() == rescuedEntity) { orphanRemovals.remove( i ); return; } } } throw new AssertionFailure( "Unable to perform un-delete for instance " + entry.getEntityName() ); }
assertTrue( dp instanceof HibernateProxy ); LazyInitializer dpLI = ( ( HibernateProxy ) dp ).getHibernateLazyInitializer(); assertTrue( dpLI.isUninitialized() ); checkReadOnly( s, dp, false ); dpLI.setReadOnly( true ); checkReadOnly( s, dp, true ); dp.setDescription( "changed" ); assertFalse( dpLI.isUninitialized() ); assertEquals( "changed", dp.getDescription() ); checkReadOnly( s, dp, true );
assertTrue( dp instanceof HibernateProxy ); LazyInitializer dpLI = ( ( HibernateProxy ) dp ).getHibernateLazyInitializer(); assertTrue( dpLI.isUninitialized() ); checkReadOnly( s, dp, false ); dp.setDescription( "changed" ); assertFalse( dpLI.isUninitialized() ); assertEquals( "changed", dp.getDescription() ); checkReadOnly( s, dp, false );
@Test public void testProxyIdentifier() { TargetNotAuditedEntity rev1 = getAuditReader().find( TargetNotAuditedEntity.class, tnae1.getId(), 1 ); Assert.assertTrue( rev1.getReference() instanceof HibernateProxy ); HibernateProxy proxyCreateByEnvers = (HibernateProxy) rev1.getReference(); LazyInitializer lazyInitializer = proxyCreateByEnvers.getHibernateLazyInitializer(); Assert.assertTrue( lazyInitializer.isUninitialized() ); Assert.assertNotNull( lazyInitializer.getIdentifier() ); Assert.assertEquals( tnae1.getId(), lazyInitializer.getIdentifier() ); Assert.assertTrue( lazyInitializer.isUninitialized() ); Assert.assertEquals( uste1.getId(), rev1.getReference().getId() ); Assert.assertEquals( uste1.getStr(), rev1.getReference().getStr() ); Assert.assertFalse( lazyInitializer.isUninitialized() ); }
private void checkProxyReadOnly(Session s, Object proxy, boolean expectedReadOnly) { assertTrue( proxy instanceof HibernateProxy ); LazyInitializer li = ( ( HibernateProxy ) proxy ).getHibernateLazyInitializer(); assertSame( s, li.getSession() ); assertEquals( expectedReadOnly, s.isReadOnly( proxy ) ); assertEquals( expectedReadOnly, li.isReadOnly() ); assertEquals( Hibernate.isInitialized( proxy ), ! li.isUninitialized() ); if ( Hibernate.isInitialized( proxy ) ) { assertEquals( expectedReadOnly, s.isReadOnly( li.getImplementation() ) ); } }
private void checkReadOnly(Session s, Object proxy, boolean expectedReadOnly) { assertTrue( proxy instanceof HibernateProxy ); LazyInitializer li = ( ( HibernateProxy ) proxy ).getHibernateLazyInitializer(); assertSame( s, li.getSession() ); assertEquals( expectedReadOnly, s.isReadOnly( proxy ) ); assertEquals( expectedReadOnly, li.isReadOnly() ); assertEquals( Hibernate.isInitialized( proxy ), ! li.isUninitialized() ); if ( Hibernate.isInitialized( proxy ) ) { assertEquals( expectedReadOnly, s.isReadOnly( li.getImplementation() ) ); } } }