toplinktemplate.java

Spring API核心源代码 Spring API核心源代码 Spring API核心源代码

		return executeFind(new SessionReadCallback(enforceReadOnly) {
			protected Object readFromSession(Session session) throws TopLinkException {
				return session.readAllObjects(entityClass, expression);
			}
		});
	}

	public List readAll(Class entityClass, Call call) throws DataAccessException {
		return readAll(entityClass, call, false);
	}

	public List readAll(final Class entityClass, final Call call, final boolean enforceReadOnly)
			throws DataAccessException {

		return executeFind(new SessionReadCallback(enforceReadOnly) {
			protected Object readFromSession(Session session) throws TopLinkException {
				return session.readAllObjects(entityClass, call);
			}
		});
	}

	public Object read(Class entityClass, Expression expression) throws DataAccessException {
		return read(entityClass, expression, false);
	}

	public Object read(final Class entityClass, final Expression expression, final boolean enforceReadOnly)
			throws DataAccessException {

		return execute(new SessionReadCallback(enforceReadOnly) {
			protected Object readFromSession(Session session) throws TopLinkException {
				return session.readObject(entityClass, expression);
			}
		});
	}

	public Object read(Class entityClass, Call call) throws DataAccessException {
		return read(entityClass, call, false);
	}

	public Object read(final Class entityClass, final Call call, final boolean enforceReadOnly)
			throws DataAccessException {

		return execute(new SessionReadCallback(enforceReadOnly) {
			protected Object readFromSession(Session session) throws TopLinkException {
				return session.readObject(entityClass, call);
			}
		});
	}


	//-------------------------------------------------------------------------
	// Convenience methods for reading an individual object by id
	//-------------------------------------------------------------------------

	public Object readById(Class entityClass, Object id) throws DataAccessException {
		return readById(entityClass, id, false);
	}

	public Object readById(Class entityClass, Object id, boolean enforceReadOnly) throws DataAccessException {
		return readById(entityClass, new Object[] {id}, enforceReadOnly);
	}

	public Object readById(Class entityClass, Object[] keys) throws DataAccessException {
		return readById(entityClass, keys, false);
	}

	public Object readById(final Class entityClass, final Object[] keys, final boolean enforceReadOnly)
			throws DataAccessException {

		Assert.isTrue(keys != null && keys.length > 0, "Non-empty keys or id is required");

		ReadObjectQuery query = new ReadObjectQuery(entityClass);
		query.setSelectionKey(new Vector(Arrays.asList(keys)));
		Object result = executeQuery(query, enforceReadOnly);

		if (result == null) {
			Object identifier = (keys.length == 1 ? keys[0] : StringUtils.arrayToCommaDelimitedString(keys));
			throw new ObjectRetrievalFailureException(entityClass, identifier);
		}
		return result;
	}

	public Object readAndCopy(Class entityClass, Object id) throws DataAccessException {
		return readAndCopy(entityClass, id, false);
	}

	public Object readAndCopy(Class entityClass, Object id, boolean enforceReadOnly)
			throws DataAccessException {

		Object entity = readById(entityClass, id, enforceReadOnly);
		return copy(entity);
	}

	public Object readAndCopy(Class entityClass, Object[] keys) throws DataAccessException {
		return readAndCopy(entityClass, keys, false);
	}

	public Object readAndCopy(Class entityClass, Object[] keys, boolean enforceReadOnly)
			throws DataAccessException {

		Object entity = readById(entityClass, keys, enforceReadOnly);
		return copy(entity);
	}


	//-------------------------------------------------------------------------
	// Convenience methods for copying and refreshing objects
	//-------------------------------------------------------------------------

	public Object copy(Object entity) throws DataAccessException {
		ObjectCopyingPolicy copyingPolicy = new ObjectCopyingPolicy();
		copyingPolicy.cascadeAllParts();
		copyingPolicy.setShouldResetPrimaryKey(false);
		return copy(entity, copyingPolicy);
	}

	public Object copy(final Object entity, final ObjectCopyingPolicy copyingPolicy)
			throws DataAccessException {

		return execute(new TopLinkCallback() {
			public Object doInTopLink(Session session) throws TopLinkException {
				return session.copyObject(entity, copyingPolicy);
			}
		});
	}

	public List copyAll(Collection entities) throws DataAccessException {
		ObjectCopyingPolicy copyingPolicy = new ObjectCopyingPolicy();
		copyingPolicy.cascadeAllParts();
		copyingPolicy.setShouldResetPrimaryKey(false);
		return copyAll(entities, copyingPolicy);
	}

	public List copyAll(final Collection entities, final ObjectCopyingPolicy copyingPolicy)
			throws DataAccessException {

		return (List) execute(new TopLinkCallback() {
			public Object doInTopLink(Session session) throws TopLinkException {
				List result = new ArrayList(entities.size());
				for (Iterator it = entities.iterator(); it.hasNext();) {
					Object entity = it.next();
					result.add(session.copyObject(entity, copyingPolicy));
				}
				return result;
			}
		});
	}

	public Object refresh(Object entity) throws DataAccessException {
		return refresh(entity, false);
	}

	public Object refresh(final Object entity, final boolean enforceReadOnly) throws DataAccessException {
		return execute(new SessionReadCallback(enforceReadOnly) {
			protected Object readFromSession(Session session) throws TopLinkException {
				return session.refreshObject(entity);
			}
		});
	}

	public List refreshAll(Collection entities) throws DataAccessException {
		return refreshAll(entities, false);
	}

	public List refreshAll(final Collection entities, final boolean enforceReadOnly) throws DataAccessException {
		return (List) execute(new SessionReadCallback(enforceReadOnly) {
			protected Object readFromSession(Session session) throws TopLinkException {
				List result = new ArrayList(entities.size());
				for (Iterator it = entities.iterator(); it.hasNext();) {
					Object entity = it.next();
					result.add(session.refreshObject(entity));
				}
				return result;
			}
		});
	}


	//-------------------------------------------------------------------------
	// Convenience methods for persisting and deleting objects
	//-------------------------------------------------------------------------

	public Object register(final Object entity) {
		return execute(new UnitOfWorkCallback() {
			protected Object doInUnitOfWork(UnitOfWork unitOfWork) throws TopLinkException {
				return unitOfWork.registerObject(entity);
			}
		});
	}

	public List registerAll(final Collection entities) {
		return (List) execute(new UnitOfWorkCallback() {
			protected Object doInUnitOfWork(UnitOfWork unitOfWork) throws TopLinkException {
				return unitOfWork.registerAllObjects(entities);
			}
		});
	}

	public void registerNew(final Object entity) {
		execute(new UnitOfWorkCallback() {
			protected Object doInUnitOfWork(UnitOfWork unitOfWork) throws TopLinkException {
				return unitOfWork.registerNewObject(entity);
			}
		});
	}

	public Object registerExisting(final Object entity) {
		return execute(new UnitOfWorkCallback() {
			protected Object doInUnitOfWork(UnitOfWork unitOfWork) throws TopLinkException {
				return unitOfWork.registerExistingObject(entity);
			}
		});
	}

	public Object merge(final Object entity) throws DataAccessException {
		return execute(new UnitOfWorkCallback() {
			protected Object doInUnitOfWork(UnitOfWork unitOfWork) throws TopLinkException {
				return unitOfWork.mergeClone(entity);
			}
		});
	}

	public Object deepMerge(final Object entity) throws DataAccessException {
		return execute(new UnitOfWorkCallback() {
			protected Object doInUnitOfWork(UnitOfWork unitOfWork) throws TopLinkException {
				return unitOfWork.deepMergeClone(entity);
			}
		});
	}

	public Object shallowMerge(final Object entity) throws DataAccessException {
		return execute(new UnitOfWorkCallback() {
			protected Object doInUnitOfWork(UnitOfWork unitOfWork) throws TopLinkException {
				return unitOfWork.shallowMergeClone(entity);
			}
		});
	}

	public Object mergeWithReferences(final Object entity) throws DataAccessException {
		return execute(new UnitOfWorkCallback() {
			protected Object doInUnitOfWork(UnitOfWork unitOfWork) throws TopLinkException {
				return unitOfWork.mergeCloneWithReferences(entity);
			}
		});
	}

	public void delete(final Object entity) throws DataAccessException {
		execute(new UnitOfWorkCallback() {
			protected Object doInUnitOfWork(UnitOfWork unitOfWork) throws TopLinkException {
				return unitOfWork.deleteObject(entity);
			}
		});
	}

	public void deleteAll(final Collection entities) throws DataAccessException {
		execute(new UnitOfWorkCallback() {
			protected Object doInUnitOfWork(UnitOfWork unitOfWork) throws TopLinkException {
				unitOfWork.deleteAllObjects(entities);
				return null;
			}
		});
	}

}