下面列出了org.hibernate.ObjectNotFoundException#org.hibernate.exception.ConstraintViolationException 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
@Test
void email_has_unique_constraint() {
UserData userData = new UserData.Builder()
.username("username")
.password("password")
.email("[email protected]")
.build();
store.createUser(userData);
UserData newUserData = new UserData.Builder()
.username("new.username")
.password("new.password")
.email("[email protected]")
.build();
assertThatExceptionOfType(ConstraintViolationException.class)
.isThrownBy(() -> store.createUser(newUserData));
}
@Test
public void testConstraintException() {
ConstraintViolationException exception = new ConstraintViolationException("message", null, "constraint");
ExceptionMapperRegistry exceptionMapperRegistry = boot.getExceptionMapperRegistry();
HibernateConstraintViolationExceptionMapper mapper = (HibernateConstraintViolationExceptionMapper) exceptionMapperRegistry.findMapperFor(ConstraintViolationException.class).get();
ErrorResponse response = mapper.toErrorResponse(exception);
ErrorData errorData = response.getErrors().iterator().next();
Assert.assertEquals(Integer.toString(HttpStatus.UNPROCESSABLE_ENTITY_422), errorData.getStatus());
Assert.assertEquals(exception.getConstraintName(), errorData.getCode());
Assert.assertEquals(exception.getMessage(), errorData.getDetail());
Assert.assertTrue(mapper.accepts(response));
ConstraintViolationException deserializedException = mapper.fromErrorResponse(response);
Assert.assertEquals(exception.getMessage(), deserializedException.getMessage());
Assert.assertEquals(exception.getConstraintName(), deserializedException.getConstraintName());
}
/**
* Convert the given SQLException into Hibernate's JDBCException hierarchy.
*
* @param sqlException The SQLException to be converted.
* @param message An optional error message.
* @param sql Optionally, the sql being performed when the exception occurred.
* @return The resulting JDBCException; returns null if it could not be converted.
*/
@Override
public JDBCException convert(SQLException sqlException, String message, String sql) {
String sqlStateClassCode = JdbcExceptionHelper.extractSqlStateClassCode( sqlException );
if ( sqlStateClassCode != null ) {
Integer errorCode = JdbcExceptionHelper.extractErrorCode( sqlException );
if ( INTEGRITY_VIOLATION_CATEGORIES.contains( errorCode ) ) {
String constraintName =
getConversionContext()
.getViolatedConstraintNameExtracter()
.extractConstraintName( sqlException );
return new ConstraintViolationException( message, sqlException, sql, constraintName );
}
else if ( DATA_CATEGORIES.contains( sqlStateClassCode ) ) {
return new DataException( message, sqlException, sql );
}
}
return null; // allow other delegates the chance to look
}
@Override
public SQLExceptionConversionDelegate buildSQLExceptionConversionDelegate() {
return new SQLExceptionConversionDelegate() {
@Override
public JDBCException convert(SQLException sqlException, String message, String sql) {
final String sqlState = JdbcExceptionHelper.extractSqlState( sqlException );
final int errorCode = JdbcExceptionHelper.extractErrorCode( sqlException );
if("JZ0TO".equals( sqlState ) || "JZ006".equals( sqlState )){
throw new LockTimeoutException( message, sqlException, sql );
}
if ( 515 == errorCode && "ZZZZZ".equals( sqlState ) ) {
// Attempt to insert NULL value into column; column does not allow nulls.
final String constraintName = getViolatedConstraintNameExtracter().extractConstraintName( sqlException );
return new ConstraintViolationException( message, sqlException, sql, constraintName );
}
return null;
}
};
}
@Test
public void testInterceptorWithFlushFailure() throws Throwable {
SQLException sqlEx = new SQLException("argh", "27");
ConstraintViolationException jdbcEx = new ConstraintViolationException("", sqlEx, null);
willThrow(jdbcEx).given(session).flush();
HibernateInterceptor interceptor = new HibernateInterceptor();
interceptor.setSessionFactory(sessionFactory);
try {
interceptor.invoke(invocation);
fail("Should have thrown DataIntegrityViolationException");
}
catch (DataIntegrityViolationException ex) {
// expected
assertEquals(jdbcEx, ex.getCause());
}
verify(session).close();
}
@RequestMapping(value = "/{id}", method = RequestMethod.PUT)
public FormValidationResultRepresentation<DataSourceForm> updateDataSource(@PathVariable("id") Long id, @RequestBody @Valid DataSourceForm dataSourceForm, BindingResult bindingResult) {
log.debug("updateDataSource() - dataSourceForm: {}, bindingResult: {}", dataSourceForm, bindingResult);
if (bindingResult.hasErrors()) {
List<FormErrorRepresentation> formErrors = ValidationUtil.extractFormErrors(bindingResult);
return new FormValidationResultRepresentation<>(dataSourceForm, formErrors);
}
//FIXME - move to domain
try {
dataSourceManagementService.updateDataSource(dataSourceForm);
} catch (Throwable e) {
log.error(e.getMessage());
if (e.getCause() instanceof ConstraintViolationException) {
throw new PlatformRuntimeException("Data source can not be updated. If you want to change available columns then you need to detach they from module firstly.");
} else {
throw e;
}
}
return new FormValidationResultRepresentation<>(dataSourceForm);
}
/**
* Returns {@code true} if the given throwable is or is not caused by a database constraint violation.
*
* @param exception - throwable to check.
*
* @return {@code true} if is constraint violation, {@code false} otherwise.
*/
private boolean isCausedByConstraintViolationException(Exception exception)
{
// some databases will throw ConstraintViolationException
boolean isConstraintViolation = ExceptionUtils.indexOfThrowable(exception, ConstraintViolationException.class) != -1;
// other databases will not throw a nice exception
if (!isConstraintViolation)
{
// We must manually check the error codes
Throwable rootThrowable = getRootCause(exception);
if (rootThrowable instanceof SQLException)
{
SQLException sqlException = (SQLException) rootThrowable;
if (POSTGRES_SQL_STATE_CODE_FOREIGN_KEY_VIOLATION.equals(sqlException.getSQLState())
|| POSTGRES_SQL_STATE_CODE_UNIQUE_INDEX_OR_PRIMARY_KEY_VIOLATION.equals(sqlException.getSQLState()))
{
isConstraintViolation = true;
}
}
}
return isConstraintViolation;
}
@Transactional
private void handle(APIAttachPoliciesToUserMsg msg) {
for (String puuid : msg.getPolicyUuids()) {
try {
UserPolicyRefVO refVO = new UserPolicyRefVO();
refVO.setUserUuid(msg.getUserUuid());
refVO.setPolicyUuid(puuid);
dbf.getEntityManager().persist(refVO);
dbf.getEntityManager().flush();
} catch (Throwable t) {
if (!ExceptionDSL.isCausedBy(t, ConstraintViolationException.class)) {
throw t;
}
// the policy is already attached
}
}
APIAttachPoliciesToUserEvent evt = new APIAttachPoliciesToUserEvent(msg.getId());
bus.publish(evt);
}
private void handle(APIAttachPolicyToUserGroupMsg msg) {
UserGroupPolicyRefVO grvo = new UserGroupPolicyRefVO();
grvo.setGroupUuid(msg.getGroupUuid());
grvo.setPolicyUuid(msg.getPolicyUuid());
try {
dbf.persist(grvo);
} catch (Throwable t) {
if (!ExceptionDSL.isCausedBy(t, ConstraintViolationException.class)) {
throw t;
}
// the policy is already attached
}
APIAttachPolicyToUserGroupEvent evt = new APIAttachPolicyToUserGroupEvent(msg.getId());
bus.publish(evt);
}
@Test
public void testSubscribe_IfCoreServiceThrowsException_checkNumberOfRetries() {
NotificationService mockNotificationService = mock(NotificationService.class);
when(mockNotificationService.subscribe(notificationSubscriptionContext1)).thenThrow(new ConstraintViolationException(IDENTITY_NAME_1, null, IDENTITY_NAME_1));
learnServiceImpl.setNotificationService(mockNotificationService);
try {
verify(learnServiceImpl.subscribe(notificationSubscriptionContext1));
} catch (Exception e) {
System.out.println("catch to check for number of retries");
}
// the number of retries for ConstraintViolationException is configured via maxRetriesPerException bean property in lmsLearnTestContext.xml
verify(mockNotificationService, times(2)).subscribe(notificationSubscriptionContext1);
}
@Test
public void isRetryStillAllowed_oneExceptionType_oneRetryAllowed() {
Map<String, Long> retriesPerException = new HashMap<String, Long>();
assertTrue(transactionRetryer.isRetryStillAllowed(retriesPerException));
// retry once allowed
transactionRetryer.addOrIncrementRetries(retriesPerException, ConstraintViolationException.class.getName());
assertTrue(transactionRetryer.isRetryStillAllowed(retriesPerException));
// retry second time no more allowed
transactionRetryer.addOrIncrementRetries(retriesPerException, ConstraintViolationException.class.getName());
assertFalse(transactionRetryer.isRetryStillAllowed(retriesPerException));
// retry no more allowed
transactionRetryer.addOrIncrementRetries(retriesPerException, ConstraintViolationException.class.getName());
assertFalse(transactionRetryer.isRetryStillAllowed(retriesPerException));
}
@Test
public void isRetryStillAllowed_oneExceptionType_oneRetryAllowed() {
Map<String, Long> retriesPerException = new HashMap<String, Long>();
assertTrue(transactionRetryer.isRetryStillAllowed(retriesPerException));
// retry once allowed
transactionRetryer.addOrIncrementRetries(retriesPerException, ConstraintViolationException.class.getName());
assertTrue(transactionRetryer.isRetryStillAllowed(retriesPerException));
// retry second time no more allowed
transactionRetryer.addOrIncrementRetries(retriesPerException, ConstraintViolationException.class.getName());
assertFalse(transactionRetryer.isRetryStillAllowed(retriesPerException));
// retry no more allowed
transactionRetryer.addOrIncrementRetries(retriesPerException, ConstraintViolationException.class.getName());
assertFalse(transactionRetryer.isRetryStillAllowed(retriesPerException));
}
private Set<Blueprint> updateDefaultBlueprintCollection(Workspace workspace) {
Set<Blueprint> blueprintsInDatabase = blueprintRepository.findAllByWorkspaceIdAndStatusIn(workspace.getId(),
Set.of(DEFAULT, DEFAULT_DELETED, USER_MANAGED));
if (!blueprintLoaderService.isAddingDefaultBlueprintsNecessaryForTheUser(blueprintsInDatabase)) {
if (blueprintLoaderService.defaultBlueprintDoesNotExistInTheCache(blueprintsInDatabase)) {
blueprintLoaderService.deleteOldDefaults(blueprintsInDatabase);
}
return blueprintsInDatabase.stream()
.filter(bp -> DEFAULT.equals(bp.getStatus()) || DEFAULT_DELETED.equals(bp.getStatus()))
.collect(Collectors.toSet());
}
LOGGER.debug("Modifying blueprints based on the defaults for the '{}' workspace.", workspace.getId());
try {
Set<Blueprint> updatedBlueprints =
blueprintLoaderService.loadBlueprintsForTheWorkspace(blueprintsInDatabase, workspace, this::saveDefaultsWithReadRight);
LOGGER.debug("Blueprint modifications finished based on the defaults for '{}' workspace.", workspace.getId());
return updatedBlueprints;
} catch (ConstraintViolationException e) {
return updateDefaultBlueprintCollection(workspace);
}
}
@Override
public SQLExceptionConverter buildSQLExceptionConverter() {
return new SQLExceptionConverter() {
@Override
public JDBCException convert(SQLException sqlException, String message, String sql) {
final int errorCode = sqlException.getErrorCode();
if (errorCode == SQLITE_CONSTRAINT) {
final String constraintName = EXTRACTER.extractConstraintName(sqlException);
return new ConstraintViolationException(message, sqlException, sql, constraintName);
} else if (errorCode == SQLITE_TOOBIG || errorCode == SQLITE_MISMATCH) {
return new DataException(message, sqlException, sql);
} else if (errorCode == SQLITE_BUSY || errorCode == SQLITE_LOCKED) {
return new LockAcquisitionException(message, sqlException, sql);
} else if ((errorCode >= SQLITE_IOERR && errorCode <= SQLITE_PROTOCOL) || errorCode == SQLITE_NOTADB) {
return new JDBCConnectionException(message, sqlException, sql);
}
return new GenericJDBCException(message, sqlException, sql);
}
};
}
@Test(expected = ConstraintViolationException.class)
public void updateSamWithNullDriversLicenseWithSessionFlush() throws Throwable {
updateSamWithNullDriversLicense();
// Manual flush is required to avoid false positive in test
try {
sessionFactory.getCurrentSession().flush();
}
catch (PersistenceException ex) {
// Wrapped in Hibernate 5.2, with the constraint violation as cause
throw ex.getCause();
}
}
@Test(expected = ConstraintViolationException.class)
public void updateSamWithNullDriversLicenseWithSessionFlush() throws Throwable {
updateSamWithNullDriversLicense();
// Manual flush is required to avoid false positive in test
try {
sessionFactory.getCurrentSession().flush();
}
catch (PersistenceException ex) {
// Wrapped in Hibernate 5.2, with the constraint violation as cause
throw ex.getCause();
}
}
@Test
void token_has_unique_constraint() {
store.createSession("token123", "userJid1");
assertThatExceptionOfType(ConstraintViolationException.class)
.isThrownBy(() -> store.createSession("token123", "userJid2"));
}
@Override
public Response toResponse(PersistenceException exception) {
if (exception.getCause() instanceof ConstraintViolationException) {
return ResponseFactory
.response(Response.Status.CONFLICT, new ErrorResponse(Response.Status.CONFLICT.getStatusCode(), Messages.CONFLICT_MESSAGE));
}
logger.error("Error: ", exception);
return ResponseFactory
.response(Response.Status.INTERNAL_SERVER_ERROR, new ErrorResponse(exception.getMessage()));
}
@Override
public void flush(RequestScope requestScope) {
try {
super.flush(requestScope);
} catch (TransactionException e) {
PersistenceException pe = (PersistenceException) e.getCause();
if (pe.getCause() instanceof ConstraintViolationException) {
throw new UnprocessableEntityException(
"Some fields violate constraint(notnull, unique, ...)", e);
} else {
throw e;
}
}
}
/**
* Handles javax.validation.ConstraintViolationException. Thrown when @Validated fails.
*
* @param ex the ConstraintViolationException
* @return the ApiError object
*/
@ExceptionHandler(javax.validation.ConstraintViolationException.class)
protected ResponseEntity<Object> handleConstraintViolation(
javax.validation.ConstraintViolationException ex) {
ApiError apiError = new ApiError(BAD_REQUEST);
apiError.setMessage("Validation error");
apiError.addValidationErrors(ex.getConstraintViolations());
return buildResponseEntity(apiError);
}
/**
* Handle DataIntegrityViolationException, inspects the cause for different DB causes.
*
* @param ex the DataIntegrityViolationException
* @return the ApiError object
*/
@ExceptionHandler(DataIntegrityViolationException.class)
protected ResponseEntity<Object> handleDataIntegrityViolation(DataIntegrityViolationException ex,
WebRequest request) {
if (ex.getCause() instanceof ConstraintViolationException) {
return buildResponseEntity(new ApiError(HttpStatus.CONFLICT, "Database error", ex.getCause()));
}
return buildResponseEntity(new ApiError(HttpStatus.INTERNAL_SERVER_ERROR, ex));
}
@Override
public ErrorResponse toErrorResponse(ConstraintViolationException cve) {
HashMap<String, Object> meta = new HashMap<>();
meta.put(META_TYPE_KEY, HIBERNATE_CONSTRAINT_VIOLATION_EXCEPTION);
ErrorData error = ErrorData.builder()
.setMeta(meta)
.setStatus(Integer.toString(HttpStatus.UNPROCESSABLE_ENTITY_422))
.setCode(cve.getConstraintName()).setDetail(cve.getCause() != null ? cve.getCause().getMessage() : cve.getMessage())
.build();
return ErrorResponse.builder().setStatus(HttpStatus.UNPROCESSABLE_ENTITY_422).setSingleErrorData(error).build();
}
@Override
public ConstraintViolationException fromErrorResponse(ErrorResponse errorResponse) {
Iterable<ErrorData> errors = errorResponse.getErrors();
ErrorData error = errors.iterator().next();
String msg = error.getDetail();
String constraintName = error.getCode();
return new ConstraintViolationException(msg, null, constraintName);
}
@Override
public JDBCException convert(SQLException sqlException, String message, String sql) {
if ( SQLClientInfoException.class.isInstance( sqlException )
|| SQLInvalidAuthorizationSpecException.class.isInstance( sqlException )
|| SQLNonTransientConnectionException.class.isInstance( sqlException )
|| SQLTransientConnectionException.class.isInstance( sqlException ) ) {
return new JDBCConnectionException( message, sqlException, sql );
}
else if ( DataTruncation.class.isInstance( sqlException ) ||
SQLDataException.class.isInstance( sqlException ) ) {
throw new DataException( message, sqlException, sql );
}
else if ( SQLIntegrityConstraintViolationException.class.isInstance( sqlException ) ) {
return new ConstraintViolationException(
message,
sqlException,
sql,
getConversionContext().getViolatedConstraintNameExtracter().extractConstraintName( sqlException )
);
}
else if ( SQLSyntaxErrorException.class.isInstance( sqlException ) ) {
return new SQLGrammarException( message, sqlException, sql );
}
else if ( SQLTimeoutException.class.isInstance( sqlException ) ) {
return new QueryTimeoutException( message, sqlException, sql );
}
else if ( SQLTransactionRollbackException.class.isInstance( sqlException ) ) {
// Not 100% sure this is completely accurate. The JavaDocs for SQLTransactionRollbackException state that
// it indicates sql states starting with '40' and that those usually indicate that:
// <quote>
// the current statement was automatically rolled back by the database because of deadlock or
// other transaction serialization failures.
// </quote>
return new LockAcquisitionException( message, sqlException, sql );
}
return null; // allow other delegates the chance to look
}
public static ModelException convert(Throwable t) {
if (t.getCause() != null && t.getCause() instanceof ConstraintViolationException) {
throw new ModelDuplicateException(t);
} if (t instanceof EntityExistsException) {
throw new ModelDuplicateException(t);
} else {
throw new ModelException(t);
}
}
/**
* Erase bi object parameter.
*
* @param aBIObjectParameter
* the a bi object parameter
*
* @throws EMFUserError
* the EMF user error
*
* @see it.eng.spagobi.behaviouralmodel.analyticaldriver.dao.IBIObjectParameterDAO#eraseBIObjectParameter(it.eng.spagobi.behaviouralmodel.analyticaldriver.bo.BIObjectParameter)
*/
@Override
public void eraseBIObjectParameter(BIObjectParameter aBIObjectParameter, boolean alsoDependencies) throws HibernateException {
Session aSession = null;
Transaction tx = null;
try {
aSession = getSession();
tx = aSession.beginTransaction();
eraseBIObjectParameter(aBIObjectParameter, aSession, alsoDependencies);
tx.commit();
} catch (ConstraintViolationException e) {
throw new HibernateException(e.getLocalizedMessage(), e);
} catch (HibernateException he) {
logException(he);
if (tx != null)
tx.rollback();
throw new HibernateException(he.getLocalizedMessage(), he);
} finally {
if (aSession != null) {
if (aSession.isOpen())
aSession.close();
}
}
}
/**
* Handles javax.validation.ConstraintViolationException. Thrown when @Validated fails.
*
* @param ex the ConstraintViolationException
* @return the ApiError object
*/
@ExceptionHandler(javax.validation.ConstraintViolationException.class)
protected ResponseEntity<Object> handleConstraintViolation(javax.validation.ConstraintViolationException ex) {
RestApiError apiError = new RestApiError(BAD_REQUEST);
apiError.setMessage("Validation error");
apiError.addValidationErrors(ex.getConstraintViolations());
return buildResponseEntity(apiError);
}
/**
* Handle DataIntegrityViolationException, inspects the cause for different DB causes.
*
* @param ex the DataIntegrityViolationException
* @return the ApiError object
*/
@ExceptionHandler(DataIntegrityViolationException.class)
protected ResponseEntity<Object> handleDataIntegrityViolation(DataIntegrityViolationException ex,
WebRequest request) {
if (ex.getCause() instanceof ConstraintViolationException) {
return buildResponseEntity(new RestApiError(HttpStatus.CONFLICT, "Database error", ex.getCause()));
}
return buildResponseEntity(new RestApiError(HttpStatus.INTERNAL_SERVER_ERROR, ex));
}
public void delete(final Long id) {
log.debug("delete() - id: {}", id);
try {
roleRepository.delete(id);
} catch (Throwable e) {
e.printStackTrace();
if (e.getCause() instanceof ConstraintViolationException) {
log.warn("The role id: {} you want to remove is assigned to users.", id);
throw new PlatformRuntimeException("The role you want to remove is assigned to users.");
} else {
throw e;
}
}
}
@Test
public void whenDuplicateIdSaved_thenConstraintViolationException() {
thrown.expect(isA(PersistenceException.class));
thrown.expectCause(isA(ConstraintViolationException.class));
thrown.expectMessage(
"ConstraintViolationException: could not execute statement");
Session session = null;
Transaction transaction = null;
for (int i = 1; i <= 2; i++) {
try {
session = sessionFactory.openSession();
transaction = session.beginTransaction();
Product product = new Product();
product.setId(1);
product.setName("Product " + i);
session.save(product);
transaction.commit();
} catch (Exception e) {
rollbackTransactionQuietly(transaction);
throw (e);
} finally {
closeSessionQuietly(session);
}
}
}