sessionimpl.java

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

			log.error("exception in interceptor beforeTransactionCompletion()", t);
		}
	}

	public void afterTransactionCompletion(boolean success, Transaction tx) {
		log.trace( "after transaction completion" );

		persistenceContext.afterTransactionCompletion();
		actionQueue.afterTransactionCompletion(success);

		if ( isRootSession ) {

			try {
				interceptor.afterTransactionCompletion(tx);
			}
			catch (Throwable t) {
				log.error("exception in interceptor beforeTransactionCompletion()", t);
			}
			
		}
		
	}

	/**
	 * clear all the internal collections, just 
	 * to help the garbage collector, does not
	 * clear anything that is needed during the
	 * afterTransactionCompletion() phase
	 */
	private void cleanup() {
		persistenceContext.clear();
	}

	public LockMode getCurrentLockMode(Object object) throws HibernateException {
		if ( object == null ) throw new NullPointerException( "null object passed to getCurrentLockMode()" );
		if ( object instanceof HibernateProxy ) {
			object = ( (HibernateProxy) object ).getHibernateLazyInitializer().getImplementation(this);
			if ( object == null ) return LockMode.NONE;
		}
		EntityEntry e = persistenceContext.getEntry(object);
		if ( e == null ) throw new TransientObjectException( "Given object not associated with the session" );
		if ( e.getStatus() != Status.MANAGED ) throw new ObjectDeletedException( 
				"The given object was deleted", 
				e.getId(), e.getPersister().getEntityName() 
		);
		return e.getLockMode();
	}

	public Object getEntityUsingInterceptor(EntityKey key) throws HibernateException {
		// todo : should this get moved to PersistentContext?
		// logically, is PersistentContext the "thing" to which an interceptor gets attached?
		final Object result = persistenceContext.getEntity(key);
		if ( result == null ) {
			final Object newObject = interceptor.getEntity( key.getEntityName(), key.getIdentifier() );
			if ( newObject != null ) lock(newObject, LockMode.NONE);
			return newObject;
		}
		else {
			return result;
		}
	}

	public void saveOrUpdate(Object object) throws HibernateException {
		saveOrUpdate(null, object);
	}

	public void saveOrUpdate(String entityName, Object obj) throws HibernateException {
		SaveOrUpdateEvent event = new SaveOrUpdateEvent(entityName, obj, this);
		listeners.getSaveOrUpdateEventListener().onSaveOrUpdate(event);
	}

	public void save(Object obj, Serializable id) throws HibernateException {
		save(null, obj, id);
	}

	public Serializable save(Object obj) throws HibernateException {
		return save(null, obj);
	}

	public Serializable save(String entityName, Object object) throws HibernateException {
		SaveOrUpdateEvent event = new SaveOrUpdateEvent(entityName, object, this);
		return listeners.getSaveEventListener().onSaveOrUpdate(event);
	}

	public void save(String entityName, Object object, Serializable id) throws HibernateException {
		SaveOrUpdateEvent event = new SaveOrUpdateEvent(entityName, object, id, this);
		listeners.getSaveEventListener().onSaveOrUpdate(event);
	}

	public void update(Object obj) throws HibernateException {
		update(null, obj);
	}

	public void update(Object obj, Serializable id) throws HibernateException {
		update(null, obj, id);
	}

	public void update(String entityName, Object object) throws HibernateException {
		SaveOrUpdateEvent event = new SaveOrUpdateEvent(entityName, object, this);
		listeners.getUpdateEventListener().onSaveOrUpdate(event);
	}

	public void update(String entityName, Object object, Serializable id) throws HibernateException {
		SaveOrUpdateEvent event = new SaveOrUpdateEvent(entityName, object, id, this);
		listeners.getUpdateEventListener().onSaveOrUpdate(event);
	}

	public void lock(Object object, LockMode lockMode) throws HibernateException {
        listeners.getLockEventListener().onLock( new LockEvent(object, lockMode, this) );
	}

	public void lock(String entityName, Object object, LockMode lockMode) throws HibernateException {
		LockEvent event = new LockEvent(entityName, object, lockMode, this);
		listeners.getLockEventListener().onLock(event);
	}

	public void persist(String entityName, Object object, Map copiedAlready)
	throws HibernateException {
		PersistEvent event = new PersistEvent(entityName, object, this);
		listeners.getCreateEventListener().onPersist(event, copiedAlready);
	}

	public void persist(String entityName, Object object)
	throws HibernateException {
		PersistEvent event = new PersistEvent(entityName, object, this);
		listeners.getCreateEventListener().onPersist(event);
	}

	public void persist(Object object) throws HibernateException {
		persist(null, object);
	}

	public Object merge(String entityName, Object object)
	throws HibernateException {
		MergeEvent event = new MergeEvent(entityName, object, this);
		return listeners.getMergeEventListener().onMerge(event);
	}

	public Object merge(Object object) throws HibernateException {
		return merge(null, object);
	}

	public void merge(String entityName, Object object, Map copiedAlready) throws HibernateException {
		MergeEvent event = new MergeEvent(entityName, object, this);
		listeners.getMergeEventListener().onMerge(event, copiedAlready);
	}

	public Object saveOrUpdateCopy(String entityName, Object object)
	throws HibernateException {
		MergeEvent event = new MergeEvent(entityName, object, this);
		return listeners.getSaveOrUpdateCopyEventListener().onMerge(event);
	}

	public Object saveOrUpdateCopy(Object object) throws HibernateException {
		return saveOrUpdateCopy(null, object);
	}

	public Object saveOrUpdateCopy(String entityName, Object object, Serializable id) 
	throws HibernateException {
		MergeEvent event = new MergeEvent(entityName, object, id, this);
		return listeners.getSaveOrUpdateCopyEventListener().onMerge(event);
	}

	public Object saveOrUpdateCopy(Object object, Serializable id) 
	throws HibernateException {
		return saveOrUpdateCopy(null, object, id);
	}

	public void saveOrUpdateCopy(String entityName, Object object, Map copiedAlready) 
	throws HibernateException {
		MergeEvent event = new MergeEvent(entityName, object, this);
		listeners.getSaveOrUpdateCopyEventListener().onMerge(event, copiedAlready);
	}

	/**
	 * Delete a persistent object
	 */
	public void delete(Object object) throws HibernateException {
		DeleteEvent event = new DeleteEvent(object, this);
        listeners.getDeleteEventListener().onDelete(event);
	}

	/**
	 * Delete a persistent object
	 */
	public void delete(String entityName, Object object, boolean isCascadeDeleteEnabled) throws HibernateException {
		DeleteEvent event = new DeleteEvent(entityName, object, isCascadeDeleteEnabled, this);
        listeners.getDeleteEventListener().onDelete(event);
	}

	public void load(Object object, Serializable id) throws HibernateException {
        LoadEvent event = new LoadEvent(id, object, this);
        listeners.getLoadEventListener().onLoad(event, null);
	}

	public Object load(Class entityClass, Serializable id) throws HibernateException {
		return load( entityClass.getName(), id );
	}

	public Object load(String entityName, Serializable id) throws HibernateException {
        LoadEvent event = new LoadEvent(id, entityName, false, this);
        Object result = listeners.getLoadEventListener().onLoad(event, LoadEventListener.LOAD);

		ObjectNotFoundException.throwIfNull(result, id, entityName);
		return result;
	}

	public Object get(Class entityClass, Serializable id) throws HibernateException {
		return get( entityClass.getName(), id );
	}

	public Object get(String entityName, Serializable id) throws HibernateException {
        LoadEvent event = new LoadEvent(id, entityName, false, this);
        return listeners.getLoadEventListener().onLoad(event, LoadEventListener.GET);
	}

	/**
	 * Load the data for the object with the specified id into a newly created object.
	 * This is only called when lazily initializing a proxy.
	 * Do NOT return a proxy.
	 */
	public Object immediateLoad(String entityName, Serializable id) throws HibernateException {
		
		if ( log.isDebugEnabled() ) {
			EntityPersister persister = getFactory().getEntityPersister(entityName);
			log.debug( "initializing proxy: " + MessageHelper.infoString( persister, id, getFactory() ) );
		}
		
        LoadEvent event = new LoadEvent(id, entityName, true, this);
        Object result = listeners.getLoadEventListener().onLoad(event, LoadEventListener.IMMEDIATE_LOAD);

		ObjectNotFoundException.throwIfNull(result, id, entityName); //should it be UnresolvableObject?
		return result;
	}

	public Object internalLoad(String entityName, Serializable id, boolean nullable) throws HibernateException {
		// todo : remove
        LoadEvent event = new LoadEvent(id, entityName, true, this);
        Object result = listeners.getLoadEventListener()
        	.onLoad(event, nullable ? LoadEventListener.INTERNAL_LOAD_NULLABLE : LoadEventListener.INTERNAL_LOAD);
		if (!nullable) UnresolvableObjectException.throwIfNull(result, id, entityName);
		return result;
	}

	public Object load(Class entityClass, Serializable id, LockMode lockMode) throws HibernateException {
		return load( entityClass.getName(), id, lockMode );
	}

	public Object load(String entityName, Serializable id, LockMode lockMode) throws HibernateException {
        LoadEvent event = new LoadEvent(id, entityName, lockMode, this);
        return listeners.getLoadEventListener().onLoad(event, LoadEventListener.LOAD);
	}

	public Object get(Class entityClass, Serializable id, LockMode lockMode) throws HibernateException {
		return get( entityClass.getName(), id, lockMode );
	}

	public Object get(String entityName, Serializable id, LockMode lockMode) throws HibernateException {
        LoadEvent event = new LoadEvent(id, entityName, lockMode, this);
        return listeners.getLoadEventListener().onLoad(event, LoadEventListener.GET);
	}

	public void refresh(Object object) throws HibernateException {
		listeners.getRefreshEventListener().onRefresh( new RefreshEvent(object, this) );
	}

	public void refresh(Object object, LockMode lockMode) throws HibernateException {
		listeners.getRefreshEventListener().onRefresh( new RefreshEvent(object, lockMode, this) );
	}

	public void replicate(Object obj, ReplicationMode replicationMode) throws HibernateException {
		ReplicateEvent event = new ReplicateEvent(obj, replicationMode, this);
		listeners.getReplicateEventListener().onReplicate(event);
	}

	public void replicate(String entityName, Object obj, ReplicationMode replicationMode)
	throws HibernateException {
		ReplicateEvent event = new ReplicateEvent(entityName, obj, replicationMode, this);
		listeners.getReplicateEventListener().onReplicate(event);
	}

	/**
	 * remove any hard references to the entity that are held by the infrastructure
	 * (references held by application or other persistant instances are okay)
	 */
	public void evict(Object object) throws HibernateException {
        listeners.getEvictEventListener().onEvict( new EvictEvent(object, this) );
	}

	/**
	 * detect in-memory changes, determine if the changes are to tables
	 * named in the query and, if so, complete execution the flush
	 */
	private boolean autoFlushIfRequired(Set querySpaces) throws HibernateException {
		AutoFlushEvent event = new AutoFlushEvent(querySpaces, this);
		return listeners.getAutoFlushEventListener().onAutoFlush(event);
	}

	public boolean isDirty() throws HibernateException {
		log.debug("checking session dirtiness");
		if ( actionQueue.areInsertionsOrDeletionsQueued() ) {
			log.debug("session dirty (scheduled updates and insertions)");
			return true;
		}
		else {
			DirtyCheckEvent event = new DirtyCheckEvent(this);
			return listeners.getDirtyCheckEventListener().onDirtyCheck(event);
		}
	}

	public void flush() throws HibernateException {
		if ( persistenceContext.getCascadeLevel() > 0 ) {
			throw new HibernateException("Flush during cascade is dangerous");
		}
		listeners.getFlushEventListener().onFlush( new FlushEvent(this) );
	}

	public void forceFlush(EntityEntry e) throws HibernateException {
		if ( log.isDebugEnabled() ) {
			log.debug(
				"flushing to force deletion of re-saved object: " +
				MessageHelper.infoString( e.getPersister(), e.getId(), getFactory() )
			);
		}

		if ( persistenceContext.getCascadeLevel() > 0 ) {
			throw new ObjectDeletedException(
				"deleted object would be re-saved by cascade (remove deleted object from associations)",
				e.getId(),
				e.getPersister().getEntityName()
			);
		}

		flush();
	}

	public Filter enableFilter(String filterName) {
        FilterImpl filter = new FilterImpl( factory.getFilterDefinition(filterName) );
		enabledFilters.put(filterName, filter);
		return filter;
	}

	public Filter getEnabledFilter(String filterName) {
		return (Filter) enabledFilters.get(filterName);
	}

	public void disableFilter(String filterName) {
		enabledFilters.remove(filterName);
	}

	public Object getFilterParameterValue(String filterParameterName) {
        String[] parsed = parseFilterParameterName(filterParameterName);
		FilterImpl filter = (FilterImpl) enabledFilters.get( parsed[0] );
		if (filter == null) {
			throw new IllegalArgumentException("Filter [" + parsed[0] + "] currently not enabled");
		}
		return filter.getParameter( parsed[1] );
	}

	public Type getFilterParameterType(String filterParameterName) {
		String[] parsed = parseFilterParameterName(filterParameterName);
		FilterDefinition filterDef = factory.getFilterDefinition( parsed[0] );
		if (filterDef == null) {