Java 类javax.persistence.PessimisticLockException 实例源码

private static boolean isLockingException(final Throwable t, final boolean recurse) {
    if (t instanceof LockingException || t instanceof PessimisticLockException) {
        return true;
    }
    if (t instanceof SQLException) {
        final SQLException e = (SQLException) t;
        return e.getErrorCode() == ER_LOCK_WAIT_TIMEOUT || ST_LOCK.equals(e.getSQLState());
    }
    if (recurse) {
        for (final Throwable thr : ExceptionUtils.getThrowables(t)) {
            if (isLockingException(thr, false)) {
                return true;
            }
        }
    }
    return false;
}

@Override
public int count(ConnectorInstance connectorInstance) {
    int attempts = 0;
    while (true) {
        try {
            String ql = "SELECT COUNT(r.id) FROM Record r WHERE r.connectorInstance = :connectorInstance";
            Query query = this.getEntityManager().createQuery(ql);
            query.setParameter("connectorInstance", connectorInstance);
            return ((Number) query.getSingleResult()).intValue();
        } catch (PessimisticLockException e) {
            attempts++;
            if (attempts > 100) {
                throw e;
            }
        }
    }
}

/**
 * A strategy method to lock an object with an exclusive lock so that it can
 * be processed
 * 
 * @param entity the entity to be locked
 * @param entityManager entity manager
 * @return true if the entity was locked
 */
protected boolean lockEntity(Object entity, EntityManager entityManager) {
    if (!getEndpoint().isConsumeLockEntity()) {
        return true;
    }
    try {
        LOG.debug("Acquiring exclusive lock on entity: {}", entity);
        if (isSkipLockedEntity()) {
            entityManager.lock(entity, lockModeType, NOWAIT);
        } else {
            entityManager.lock(entity, lockModeType);
        }
        return true;
    } catch (Exception e) {
        if (LOG.isDebugEnabled()) {
            LOG.debug("Failed to achieve lock on entity: " + entity + ". Reason: " + e, e);
        }
        if (e instanceof PessimisticLockException || e instanceof OptimisticLockException) {
            //transaction marked as rollback can't continue gracefully
            throw (PersistenceException) e;
        }
        //TODO: Find if possible an alternative way to handle results of native queries.
        //Result of native queries are Arrays and cannot be locked by all JPA Providers.
        if (entity.getClass().isArray()) {
            return true;
        }
        return false;
    }
}

private int count(RecordCollection collection, Boolean updateIndex, Boolean deleted) {
    int attempts = 0;
    while (true) {
        try {
            String ql = "SELECT COUNT(r.id) FROM Record r WHERE r.connectorInstance.recordCollection = :recordCollection";
            if (Boolean.TRUE.equals(updateIndex)) {
                ql += " AND updateIndex = :updateIndex AND (excluded = false OR excluded = null)";
            }
            if (Boolean.TRUE.equals(deleted)) {
                ql += " AND deleted = :deleted";
            }
            Query query = this.getEntityManager().createQuery(ql);
            query.setParameter("recordCollection", collection);
            if (updateIndex != null && Boolean.TRUE.equals(updateIndex)) {
                query.setParameter("updateIndex", updateIndex);
            }
            if (deleted != null && Boolean.TRUE.equals(deleted)) {
                query.setParameter("deleted", deleted);
            }
            return ((Number) query.getSingleResult()).intValue();
        } catch (PessimisticLockException e) {
            attempts++;
            if (attempts > 100) {
                throw e;
            }
        }
    }
}

/**
 * Convert the given runtime exception to an appropriate exception from the
 * {@code org.springframework.dao} hierarchy.
 * Return null if no translation is appropriate: any other exception may
 * have resulted from user code, and should not be translated.
 * <p>The most important cases like object not found or optimistic locking failure
 * are covered here. For more fine-granular conversion, JpaTransactionManager etc
 * support sophisticated translation of exceptions via a JpaDialect.
 * @param ex runtime exception that occurred
 * @return the corresponding DataAccessException instance,
 * or {@code null} if the exception should not be translated
 */
public static DataAccessException convertJpaAccessExceptionIfPossible(RuntimeException ex) {
    // Following the JPA specification, a persistence provider can also
    // throw these two exceptions, besides PersistenceException.
    if (ex instanceof IllegalStateException) {
        return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
    }
    if (ex instanceof IllegalArgumentException) {
        return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
    }

    // Check for well-known PersistenceException subclasses.
    if (ex instanceof EntityNotFoundException) {
        return new JpaObjectRetrievalFailureException((EntityNotFoundException) ex);
    }
    if (ex instanceof NoResultException) {
        return new EmptyResultDataAccessException(ex.getMessage(), 1, ex);
    }
    if (ex instanceof NonUniqueResultException) {
        return new IncorrectResultSizeDataAccessException(ex.getMessage(), 1, ex);
    }
    if (ex instanceof QueryTimeoutException) {
        return new org.springframework.dao.QueryTimeoutException(ex.getMessage(), ex);
    }
    if (ex instanceof LockTimeoutException) {
        return new CannotAcquireLockException(ex.getMessage(), ex);
    }
    if (ex instanceof PessimisticLockException) {
        return new PessimisticLockingFailureException(ex.getMessage(), ex);
    }
    if (ex instanceof OptimisticLockException) {
        return new JpaOptimisticLockingFailureException((OptimisticLockException) ex);
    }
    if (ex instanceof EntityExistsException) {
        return new DataIntegrityViolationException(ex.getMessage(), ex);
    }
    if (ex instanceof TransactionRequiredException) {
        return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
    }

    // If we have another kind of PersistenceException, throw it.
    if (ex instanceof PersistenceException) {
        return new JpaSystemException((PersistenceException) ex);
    }

    // If we get here, we have an exception that resulted from user code,
    // rather than the persistence provider, so we return null to indicate
    // that translation should not occur.
    return null;
}

/**
 * Convert the given runtime exception to an appropriate exception from the
 * {@code org.springframework.dao} hierarchy.
 * Return null if no translation is appropriate: any other exception may
 * have resulted from user code, and should not be translated.
 * <p>The most important cases like object not found or optimistic locking failure
 * are covered here. For more fine-granular conversion, JpaTransactionManager etc
 * support sophisticated translation of exceptions via a JpaDialect.
 * @param ex runtime exception that occurred
 * @return the corresponding DataAccessException instance,
 * or {@code null} if the exception should not be translated
 */
public static DataAccessException convertJpaAccessExceptionIfPossible(RuntimeException ex) {
    // Following the JPA specification, a persistence provider can also
    // throw these two exceptions, besides PersistenceException.
    if (ex instanceof IllegalStateException) {
        return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
    }
    if (ex instanceof IllegalArgumentException) {
        return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
    }

    // Check for well-known PersistenceException subclasses.
    if (ex instanceof EntityNotFoundException) {
        return new JpaObjectRetrievalFailureException((EntityNotFoundException) ex);
    }
    if (ex instanceof NoResultException) {
        return new EmptyResultDataAccessException(ex.getMessage(), 1, ex);
    }
    if (ex instanceof NonUniqueResultException) {
        return new IncorrectResultSizeDataAccessException(ex.getMessage(), 1, ex);
    }
    if (ex instanceof QueryTimeoutException) {
        return new org.springframework.dao.QueryTimeoutException(ex.getMessage(), ex);
    }
    if (ex instanceof LockTimeoutException) {
        return new CannotAcquireLockException(ex.getMessage(), ex);
    }
    if (ex instanceof PessimisticLockException) {
        return new PessimisticLockingFailureException(ex.getMessage(), ex);
    }
    if (ex instanceof OptimisticLockException) {
        return new JpaOptimisticLockingFailureException((OptimisticLockException) ex);
    }
    if (ex instanceof EntityExistsException) {
        return new DataIntegrityViolationException(ex.getMessage(), ex);
    }
    if (ex instanceof TransactionRequiredException) {
        return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
    }

    // If we have another kind of PersistenceException, throw it.
    if (ex instanceof PersistenceException) {
        return new JpaSystemException((PersistenceException) ex);
    }

    // If we get here, we have an exception that resulted from user code,
    // rather than the persistence provider, so we return null to indicate
    // that translation should not occur.
    return null;
}

@Override
public void deleteAutomaticRecordTags(RecordCollection collection, Date newStartTaggingDate) {
    int attempts = 0;
    while (true) {
        try {
            String sqlTag;
            if (newStartTaggingDate == null) {
                sqlTag = "DELETE FROM RecordTag WHERE manual=? AND record_id IN"
                    + " (SELECT r.id FROM Record r, ConnectorInstance ci, RecordCollection rc"
                    + " WHERE r.connectorInstance_id=ci.id AND ci.recordCollection_id=rc.id AND rc.id=?)";
            } else {
                sqlTag = "DELETE FROM RecordTag WHERE manual=? AND record_id IN"
                    + " (SELECT r.id FROM Record r, ConnectorInstance ci, RecordCollection rc "
                    + "WHERE r.connectorInstance_id=ci.id AND ci.recordCollection_id=rc.id AND rc.id=? AND"
                    + " (r.lastAutomaticTagging > ? OR r.lastAutomaticTagging IS NULL))";
            }
            Query tagQuery = getEntityManager().createNativeQuery(sqlTag);
            tagQuery.setParameter(1, Boolean.FALSE);
            tagQuery.setParameter(2, collection.getId());
            if (newStartTaggingDate != null) {
                tagQuery.setParameter(3, newStartTaggingDate);
            }
            tagQuery.executeUpdate();

            String sqlRecord;
            if (newStartTaggingDate == null) {
                sqlRecord = "UPDATE Record r SET r.lastAutomaticTagging = null WHERE connectorInstance_id IN"
                    + " (SELECT ci.id FROM ConnectorInstance ci, RecordCollection rc WHERE ci.recordCollection_id=rc.id AND rc.id=?)";
            } else {
                sqlRecord = "UPDATE Record r SET r.lastAutomaticTagging = null WHERE connectorInstance_id IN"
                    + " (SELECT ci.id FROM ConnectorInstance ci, RecordCollection rc WHERE ci.recordCollection_id=rc.id AND"
                    + " rc.id=?) AND (r.lastAutomaticTagging > ? OR r.lastAutomaticTagging IS NULL)";
            }
            Query recordQuery = getEntityManager().createNativeQuery(sqlRecord);
            recordQuery.setParameter(1, collection.getId());
            if (newStartTaggingDate != null) {
                recordQuery.setParameter(2, newStartTaggingDate);
            }
            recordQuery.executeUpdate();
            break;
        } catch (PessimisticLockException e) {
            attempts++;
            if (attempts > 100) {
                throw e;
            }
        }
    }
}