Java PersistenceException.getMessage方法代码示例

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
public List<ReservationInformation> getAllPendingReservations(
		ExperimentType type) throws ExperimentException,
		NoReservationsAvailableException {

	try {
		List<ReservationEntry> reservationEntries;

		if (type == null) {
			reservationEntries = service.getAllReservationsFrom(new Date());
		} else {
			reservationEntries = service.getAllReservationsFromByType(
					type.name(), new Date());
		}

		if (reservationEntries == null || reservationEntries.size() == 0) {
			throw new NoReservationsAvailableException("pending");
		}

		return this.processReservationEntries(reservationEntries);

	} catch (PersistenceException e) {
		throw new ExperimentException(e.getMessage());
	}
}
 

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
public void setRTAvailability(String rt, RTAvailability availability)
		throws ActionException {

	boolean alreadyContained = false;

	try {
		if (rtService.contains(rt)) {
			alreadyContained = true;

			rtService.setStartingAvailability(rt,
					availability.getStartingTime());
			rtService.setEndingAvailability(rt,
					availability.getEndingTime());

		}
	} catch (PersistenceException e) {
		throw new ActionException(e.getMessage());
	}

	if (!alreadyContained) {
		throw new ActionException("rt does not exist");
	}
}
 

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
public void createExperiment(String experiment, String author, String type)
		throws ExperimentException, DuplicateExperimentException {

	boolean alreadyContained = true;

	try {

		if (!service.containsExperiment(experiment)) {
			alreadyContained = false;

			ExperimentEntry entry = new ExperimentEntry();
			entry.setAuthor(author);
			entry.setName(experiment);
			entry.setType(type);
			service.saveExperiment(entry);
		}

	} catch (PersistenceException e) {
		throw new ExperimentException(e.getMessage());
	}

	if (alreadyContained) {
		throw new DuplicateExperimentException(experiment);
	}
}
 

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
public void addExperimentOperation(String experiment,
		OperationInformation operationInfo) throws ExperimentException,
		NoSuchExperimentException {

	try {
		if (service.containsExperiment(experiment)) {

			int experimentId = service.getExperimentId(experiment);

			OperationEntry entry = new OperationEntry();
			entry.setExperiment(experimentId);
			entry.setType(operationInfo.getType());
			entry.setOperation(operationInfo.getName());

			service.saveExperimentOperation(entry);
		} else {
			throw new NoSuchExperimentException(experiment);
		}

	} catch (PersistenceException e) {
		throw new ExperimentException(e.getMessage());
	}
}
 

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
public void setJpg(int id, String jpg) throws ActionException {
	try {
		if (!imageService.contains(id)) {
			throw new ActionException("image does not exist");
		}

		String host = this.extractHost(jpg);

		if (host != null) {
			String fileName = this.extractFilename(jpg);

			if (fileName != null) {
				imageService.setJpg(id, host);
			} else {
				imageService.setJpg(id, host);
			}
		}
	} catch (PersistenceException e) {
		throw new ActionException(e.getMessage());
	}
}
 

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
public void setFits(int id, String fits) throws ActionException {
	try {
		if (!imageService.contains(id)) {
			throw new ActionException("image does not exist");
		}

		String host = this.extractHost(fits);

		if (host != null) {
			String fileName = this.extractFilename(fits);

			if (fileName != null) {
				imageService.setFits(id, host);
			} else {
				imageService.setFits(id, host);
			}
		}
	} catch (PersistenceException e) {
		throw new ActionException(e.getMessage());
	}
}
 

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
public boolean anyRTReservationBetween(List<String> telescopes,
		TimeSlot timeSlot) throws ExperimentException {

	boolean available = true;

	try {
		for (String rt : telescopes) {

			if (service.anyRTReservationBetween(rt, timeSlot.getBegin(),
					timeSlot.getEnd())) {

				available = false;
				break;
			}
		}
	} catch (PersistenceException e) {
		throw new ExperimentException(e.getMessage());
	}

	return !available;
}
 

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
public void clearAllObsoleteContexts() throws ExperimentException {

		try {

			List<ReservationEntry> reservationEntries = service
					.getAllReservationsShouldBeObsolete();

			for (ReservationEntry entry : reservationEntries) {
				service.removeReservationContext(entry.getIdreservation());
				service.setReservationStatus(entry.getIdreservation(),
						"OBSOLETE");
			}

		} catch (PersistenceException e) {
			throw new ExperimentException(e.getMessage());
		}

	}
 

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
@Timed("db_storage_read_operation")
@Override
@Transactional
public <T, E extends Exception> T read(Work<T, E> work) throws StorageException, E {
  try {
    return work.apply(storeProvider);
  } catch (PersistenceException e) {
    throw new StorageException(e.getMessage(), e);
  }
}
 

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
public int insert(M model) throws RepositoryException {
    // automatically set id
	if (model.getId() == 0) {
    	model.setId(nextId());
    }
	
	try{
        return getMapper().insert(model);
    }
    catch (PersistenceException e) {
        throw new RepositoryException(e.getMessage());
    }
}
 

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
public int update(M model) throws RepositoryException {
    try {
        return getMapper().update(model);
    }
    catch (PersistenceException e) {
        throw new RepositoryException(e.getMessage());
    }
}
 

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
public int delete(M model) throws RepositoryException {
    try {
        return getMapper().delete(model);
    }
    catch (PersistenceException e) {
        throw new RepositoryException(e.getMessage());
    }
}
 

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
public M get(long id) throws RepositoryException {
    try {
        return (M) getMapper().get(id);
    }
    catch (PersistenceException e) {
        throw new RepositoryException(e.getMessage());
    }
}
 

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
public int count(Map criteria) throws RepositoryException {
    try {
        return getMapper().count(criteria);
    }
    catch (PersistenceException e) {
        throw new RepositoryException(e.getMessage());
    }
}
 

import org.apache.ibatis.exceptions.PersistenceException; //导入方法依赖的package包/类
public List<M> select(Map criteria, Regulation regulation) throws RepositoryException {
	try {
        if (regulation != null && regulation.pagination != null) {
        	regulation.pagination.setRowCount(this.count(criteria));
        }
        return getMapper().select(criteria, regulation);
    }
    catch (PersistenceException e) {
        throw new RepositoryException(e.getMessage());
    }
}