} } } } private static EntityKey generateEntityKeyOrNull(Serializable id, SessionImplementor s, String entityName) { if ( id == null || s == null || entityName == null ) { return null; } return s.generateEntityKey( id, s.getFactory().getEntityPersister( entityName ) ); } @Override public final void unsetSession() { session = null; readOnly = false; readOnlyBeforeAttachedToSession = null; } @Override public final void initialize() throws HibernateException { if (!initialized) { if ( session==null ) { throw new LazyInitializationException("could not initialize proxy - no Session"); } else if ( !session.isOpen() ) { throw new LazyInitializationException("could not initialize proxy - the owning Session was closed"); } else if ( !session.isConnected() ) { throw new LazyInitializationException("could not initialize proxy - the owning Session is disconnected"); } else { target = session.immediateLoad(entityName, id); initialized = true; checkTargetState(); } } else { checkTargetState(); } } private void checkTargetState() { if ( !unwrap ) { if ( target == null ) { getSession().getFactory().getEntityNotFoundDelegate().handleEntityNotFound( entityName, id ); } } } /** * Getter for property 'connectedToSession'. * * @return Value for property 'connectedToSession'. */ protected final boolean isConnectedToSession() { return getProxyOrNull() != null; } private Object getProxyOrNull() { final EntityKey entityKey = generateEntityKeyOrNull( getIdentifier(), session, getEntityName() ); if ( entityKey != null && session != null && session.isOpen() ) { return session.getPersistenceContext().getProxy( entityKey ); } return null; } @Override public final Object getImplementation() { initialize(); return target; } @Override public final void setImplementation(Object target) { this.target = target; initialized = true; } @Override public final Object getImplementation(SessionImplementor s) throws HibernateException { final EntityKey entityKey = generateEntityKeyOrNull( getIdentifier(), s, getEntityName() ); return ( entityKey == null ? null : s.getPersistenceContext().getEntity( entityKey ) ); } /** * Getter for property 'target'. * <p/> * Same as {@link #getImplementation()} except that this method will not force initialization. * * @return Value for property 'target'. */ protected final Object getTarget() { return target; } @Override public final boolean isReadOnlySettingAvailable() { return ( session != null && ! session.isClosed() ); } private void errorIfReadOnlySettingNotAvailable() { if ( session == null ) { throw new TransientObjectException( "Proxy is detached (i.e, session is null). The read-only/modifiable setting is only accessible when the proxy is associated with an open session." ); } if ( session.isClosed() ) { throw new SessionException( "Session is closed. The read-only/modifiable setting is only accessible when the proxy is associated with an open session." ); } } @Override public final boolean isReadOnly() { errorIfReadOnlySettingNotAvailable(); return readOnly; } @Override public final void setReadOnly(boolean readOnly) { errorIfReadOnlySettingNotAvailable(); // only update if readOnly is different from current setting if ( this.readOnly != readOnly ) { final EntityPersister persister = session.getFactory().getEntityPersister( entityName ); if ( ! persister.isMutable() && ! readOnly ) { throw new IllegalStateException( "cannot make proxies for immutable entities modifiable"); } this.readOnly = readOnly; if ( initialized ) { EntityKey key = generateEntityKeyOrNull( getIdentifier(), session, getEntityName() ); if ( key != null && session.getPersistenceContext().containsEntity( key ) ) { session.getPersistenceContext().setReadOnly( target, readOnly ); } } } } /** * Get the read-only/modifiable setting that should be put in affect when it is * attached to a session. * * This method should only be called during serialization when read-only/modifiable setting * is not available (i.e., isReadOnlySettingAvailable() == false) * * @return null, if the default setting should be used; * true, for read-only; * false, for modifiable * @throws IllegalStateException if isReadOnlySettingAvailable() == true */ protected final Boolean isReadOnlyBeforeAttachedToSession() { if ( isReadOnlySettingAvailable() ) { throw new IllegalStateException( "Cannot call isReadOnlyBeforeAttachedToSession when isReadOnlySettingAvailable == true" ); } return readOnlyBeforeAttachedToSession; } /** * Set the read-only/modifiable setting that should be put in affect when it is * attached to a session. * * This method should only be called during deserialization, before associating * the proxy with a session. * * @param readOnlyBeforeAttachedToSession, the read-only/modifiable setting to use when * associated with a session; null indicates that the default should be used. * @throws IllegalStateException if isReadOnlySettingAvailable() == true */ /* package-private */ final void setReadOnlyBeforeAttachedToSession(Boolean readOnlyBeforeAttachedToSession) { if ( isReadOnlySettingAvailable() ) { throw new IllegalStateException( "Cannot call setReadOnlyBeforeAttachedToSession when isReadOnlySettingAvailable == true" ); } this.readOnlyBeforeAttachedToSession = readOnlyBeforeAttachedToSession; } @Override public boolean isUnwrap() { return unwrap; } @Override public void setUnwrap(boolean unwrap) { this.unwrap = unwrap; } }