sessionimpl.java

介绍了hibernate的入门有一些基本常用的事例

//$Id: SessionImpl.java,v 1.124 2005/04/03 01:52:14 oneovthafew Exp $
package org.hibernate.impl;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.sql.Connection;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.dom4j.Element;
import org.hibernate.CacheMode;
import org.hibernate.Criteria;
import org.hibernate.EntityMode;
import org.hibernate.Filter;
import org.hibernate.FlushMode;
import org.hibernate.HibernateException;
import org.hibernate.Interceptor;
import org.hibernate.LockMode;
import org.hibernate.MappingException;
import org.hibernate.ObjectDeletedException;
import org.hibernate.ObjectNotFoundException;
import org.hibernate.Query;
import org.hibernate.QueryException;
import org.hibernate.ReplicationMode;
import org.hibernate.SQLQuery;
import org.hibernate.ScrollMode;
import org.hibernate.ScrollableResults;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.TransientObjectException;
import org.hibernate.UnresolvableObjectException;
import org.hibernate.collection.PersistentCollection;
import org.hibernate.engine.ActionQueue;
import org.hibernate.engine.CollectionEntry;
import org.hibernate.engine.EntityEntry;
import org.hibernate.engine.EntityKey;
import org.hibernate.engine.FilterDefinition;
import org.hibernate.engine.NamedQueryDefinition;
import org.hibernate.engine.NamedSQLQueryDefinition;
import org.hibernate.engine.PersistenceContext;
import org.hibernate.engine.QueryParameters;
import org.hibernate.engine.SessionFactoryImplementor;
import org.hibernate.engine.SessionImplementor;
import org.hibernate.engine.Status;
import org.hibernate.event.AutoFlushEvent;
import org.hibernate.event.PersistEvent;
import org.hibernate.event.DeleteEvent;
import org.hibernate.event.DirtyCheckEvent;
import org.hibernate.event.EvictEvent;
import org.hibernate.event.FlushEvent;
import org.hibernate.event.InitializeCollectionEvent;
import org.hibernate.event.LoadEvent;
import org.hibernate.event.LoadEventListener;
import org.hibernate.event.LockEvent;
import org.hibernate.event.MergeEvent;
import org.hibernate.event.RefreshEvent;
import org.hibernate.event.ReplicateEvent;
import org.hibernate.event.SaveOrUpdateEvent;
import org.hibernate.event.SessionEventListenerConfig;
import org.hibernate.hql.FilterTranslator;
import org.hibernate.hql.QuerySplitter;
import org.hibernate.hql.QueryTranslator;
import org.hibernate.jdbc.Batcher;
import org.hibernate.jdbc.JDBCContext;
import org.hibernate.loader.criteria.CriteriaLoader;
import org.hibernate.loader.custom.CustomLoader;
import org.hibernate.loader.custom.CustomQuery;
import org.hibernate.persister.collection.CollectionPersister;
import org.hibernate.persister.entity.EntityPersister;
import org.hibernate.persister.entity.OuterJoinLoadable;
import org.hibernate.pretty.MessageHelper;
import org.hibernate.proxy.HibernateProxy;
import org.hibernate.proxy.LazyInitializer;
import org.hibernate.type.Type;
import org.hibernate.util.ArrayHelper;
import org.hibernate.util.CollectionHelper;
import org.hibernate.util.EmptyIterator;
import org.hibernate.util.JoinedIterator;
import org.hibernate.util.StringHelper;


/**
 * Concrete implementation of a Session, and also the central, organizing component
 * of Hibernate's internal implementation. As such, this class exposes two interfaces;
 * Session itself, to the application, and SessionImplementor, to other components
 * of Hibernate. This class is not threadsafe.
 *
 * @author Gavin King
 */
public final class SessionImpl implements SessionImplementor, JDBCContext.Context {

	// todo : need to find a clean way to handle the "event source" role
	// a seperate classs responsible for generating/dispatching events just duplicates most of the Session methods...
	// passing around seperate references to interceptor, factory, actionQueue, and persistentContext is not manageable...

	private static final Log log = LogFactory.getLog(SessionImpl.class);

	private transient SessionFactoryImpl factory;
	private EntityMode entityMode = EntityMode.POJO;

	private final long timestamp;
	private boolean closed = false;
	private FlushMode flushMode = FlushMode.AUTO;
	private CacheMode cacheMode = CacheMode.NORMAL;

	private Interceptor interceptor;

	private transient int dontFlushFromFind = 0;

	private ActionQueue actionQueue;
	private PersistenceContext persistenceContext;
	private transient JDBCContext jdbcContext;
	private SessionEventListenerConfig listeners;

	private boolean flushBeforeCompletionEnabled;
	private boolean autoCloseSessionEnabled;

	private Map enabledFilters = new HashMap();

	private boolean isRootSession = true;
	private Map childSessionsByEntityMode;


	public Session getSession(EntityMode entityMode) {
		if ( this.entityMode == entityMode ) {
			return this;
		}

		if ( childSessionsByEntityMode == null ) {
			childSessionsByEntityMode = new HashMap();
		}

		SessionImpl rtn = (SessionImpl) childSessionsByEntityMode.get( entityMode );
		if ( rtn == null ) {
			rtn = new SessionImpl( this, entityMode );
			childSessionsByEntityMode.put( entityMode, rtn );
		}

		return rtn;
	}


	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
		log.trace("deserializing session");

		interceptor = (Interceptor) ois.readObject();
		factory = (SessionFactoryImpl) ois.readObject();
		jdbcContext = (JDBCContext) ois.readObject();
		ois.defaultReadObject();
	}

	private void writeObject(ObjectOutputStream oos) throws IOException {
		if ( isConnected() ) throw new IllegalStateException( "Cannot serialize a Session while connected" );

		log.trace( "serializing session" );

		oos.writeObject(interceptor);
		oos.writeObject(factory);
		oos.writeObject(jdbcContext);
		oos.defaultWriteObject();

	}

	public void clear() {
		persistenceContext.clear();
		actionQueue.clear();
	}

	private SessionImpl(SessionImpl parent, EntityMode entityMode) {
		this.factory = parent.factory;

		this.timestamp = parent.timestamp;

		this.jdbcContext = parent.jdbcContext;

		this.interceptor = parent.interceptor;
		this.listeners = parent.listeners;

		this.actionQueue = new ActionQueue(this);

		this.entityMode = entityMode;
		this.persistenceContext = new PersistenceContext(this);

		this.isRootSession = false;

		if ( factory.getStatistics().isStatisticsEnabled() ) {
			factory.getStatisticsImplementor().openSession();
		}
		
		log.debug( "opened session [" + entityMode + "]" );
	}

	SessionImpl(
			final Connection connection,
			final SessionFactoryImpl factory,
			final boolean autoclose,
			final long timestamp,
			final Interceptor interceptor,
			final SessionEventListenerConfig listeners,
			final EntityMode entityMode,
			final boolean flushBeforeCompletionEnabled,
			final boolean autoCloseSessionEnabled) {
		this.factory = factory;

		this.timestamp = timestamp;

		this.entityMode = entityMode;

		this.interceptor = interceptor;
		this.listeners = listeners;

		this.actionQueue = new ActionQueue( this );
		this.persistenceContext = new PersistenceContext( this );

		this.isRootSession = true;

		this.flushBeforeCompletionEnabled = flushBeforeCompletionEnabled;
		this.autoCloseSessionEnabled = autoCloseSessionEnabled;

		this.jdbcContext = new JDBCContext( this, connection, autoclose );

		if ( factory.getStatistics().isStatisticsEnabled() ) {
			factory.getStatisticsImplementor().openSession();
		}
		
		if ( log.isDebugEnabled() ) log.debug( "opened session at timestamp: " + timestamp );
	}

	public Batcher getBatcher() {
		return jdbcContext.getBatcher();
	}

	public SessionFactoryImplementor getFactory() {
		return factory;
	}

	public long getTimestamp() {
		return timestamp;
	}

	public Connection close() throws HibernateException {

		log.trace( "closing session" );

		if ( factory.getStatistics().isStatisticsEnabled() ) 
			factory.getStatisticsImplementor().closeSession();

		try {
			try {
				if ( childSessionsByEntityMode != null ) {
					Iterator childSessions = childSessionsByEntityMode.values().iterator();
					while ( childSessions.hasNext() ) {
						final SessionImpl child = ( SessionImpl ) childSessions.next();
						child.close();
					}
				}
			}
			catch( Throwable t ) {
				// just ignore
			}

			if ( isRootSession ) {
				return jdbcContext.release();
			}
			else {
				return null;
			}
		}
		finally {
			closed = true;
			cleanup();
		}
	}

	public boolean isAutoDisconnectEnabled() {
		return isAutoCloseSessionEnabled() && factory.getTransactionManager() != null;
	}

	public boolean isAutoCloseSessionEnabled() {
		return autoCloseSessionEnabled;
	}

	public boolean isOpen() {
		return !closed;
	}

	public boolean isFlushModeNever() {
		return getFlushMode() == FlushMode.NEVER;
	}

	public boolean isFlushBeforeCompletionEnabled() {
		return flushBeforeCompletionEnabled;
	}

	public void managedFlush() {

		log.trace("automatically flushing session");
		flush();
		
		if ( childSessionsByEntityMode != null ) {
			Iterator iter = childSessionsByEntityMode.values().iterator();
			while ( iter.hasNext() ) {
				( (Session) iter.next() ).flush();
			}
		}
		
	}

	public boolean shouldAutoClose() {
		return isAutoCloseSessionEnabled() && isOpen();
	}

	public void managedClose() {
		log.trace("automatically closing session");
		close();
	}

	public Connection connection() throws HibernateException {
		return jdbcContext.connection();
	}

	public boolean isConnected() {
		return jdbcContext.isConnected();
	}

	public Connection disconnect() throws HibernateException {
		log.debug( "disconnecting session" );
        return jdbcContext.disconnect();
	}

	public void reconnect() throws HibernateException {
		log.debug( "reconnecting session" );
		jdbcContext.reconnect();
	}

	public void reconnect(Connection conn) throws HibernateException {
		log.debug( "reconnecting session" );
		jdbcContext.reconnect( conn );
	}

	public void beforeTransactionCompletion(Transaction tx) {
		log.trace( "before transaction completion" );

		if ( !isRootSession ) {
			log.trace( "skipping beforeTransactionCompletion processing as this is not root session" );
			return;
		}

		try {
			interceptor.beforeTransactionCompletion(tx);
		}
		catch (Throwable t) {