protected void doCommit(DefaultTransactionStatus status) {
        JpaTransactionObject txObject = (JpaTransactionObject)status.getTransaction();
        if (status.isDebug()) {
            this.logger.debug("Committing JPA transaction on EntityManager [" + txObject.getEntityManagerHolder().getEntityManager() + "]");
        }

        try {
            EntityTransaction tx = txObject.getEntityManagerHolder().getEntityManager().getTransaction();
            tx.commit();
        } catch (RollbackException var6) {
            Throwable var5 = var6.getCause();
            if (var5 instanceof RuntimeException runtimeException) {
                DataAccessException dae = this.getJpaDialect().translateExceptionIfPossible(runtimeException);
                if (dae != null) {
                    throw dae;
                }
            }

            throw new TransactionSystemException("Could not commit JPA transaction", var6);
        } catch (RuntimeException var7) {
            throw DataAccessUtils.translateIfNecessary(var7, this.getJpaDialect());
        }
 
   }

   @Nullable
    public DataAccessException translateExceptionIfPossible(RuntimeException ex) {
        if (ex instanceof HibernateException hibernateEx) {
            return this.convertHibernateAccessException(hibernateEx);
        } else {
            if (ex instanceof PersistenceException) {
                Throwable var3 = ex.getCause();
                if (var3 instanceof HibernateException) {
                    hibernateEx = (HibernateException)var3;
                    return this.convertHibernateAccessException(hibernateEx);
                }
            }

            return EntityManagerFactoryUtils.convertJpaAccessExceptionIfPossible(ex);
        }
    }

    @Nullable
    public static DataAccessException convertJpaAccessExceptionIfPossible(RuntimeException ex) {
        if (ex instanceof IllegalStateException) {
            return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
        } else if (ex instanceof IllegalArgumentException) {
            return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
        } else if (ex instanceof EntityNotFoundException) {
            EntityNotFoundException entityNotFoundException = (EntityNotFoundException)ex;
            return new JpaObjectRetrievalFailureException(entityNotFoundException);
        } else if (ex instanceof NoResultException) {
            return new EmptyResultDataAccessException(ex.getMessage(), 1, ex);
        } else if (ex instanceof NonUniqueResultException) {
            return new IncorrectResultSizeDataAccessException(ex.getMessage(), 1, ex);
        } else if (ex instanceof QueryTimeoutException) {
            return new org.springframework.dao.QueryTimeoutException(ex.getMessage(), ex);
        } else if (ex instanceof LockTimeoutException) {
            return new CannotAcquireLockException(ex.getMessage(), ex);
        } else if (ex instanceof PessimisticLockException) {
            return new PessimisticLockingFailureException(ex.getMessage(), ex);
        } else if (ex instanceof OptimisticLockException) {
            OptimisticLockException optimisticLockException = (OptimisticLockException)ex;
            return new JpaOptimisticLockingFailureException(optimisticLockException);
        } else if (ex instanceof EntityExistsException) {
            return new DataIntegrityViolationException(ex.getMessage(), ex);
        } else if (ex instanceof TransactionRequiredException) {
            return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
        } else {
            return ex instanceof PersistenceException ? new JpaSystemException(ex) : null;
        }
    }

protected DataAccessException convertHibernateAccessException(HibernateException ex) {
        DataAccessException dae;
        if (this.jdbcExceptionTranslator != null && ex instanceof JDBCException jdbcEx) {
            dae = this.jdbcExceptionTranslator.translate("Hibernate operation: " + jdbcEx.getMessage(), jdbcEx.getSQL(), jdbcEx.getSQLException());
            if (dae != null) {
                return dae;
            }
        }

        if (this.transactionExceptionTranslator != null && ex instanceof org.hibernate.TransactionException) {
            Throwable var7 = ex.getCause();
            if (var7 instanceof SQLException) {
                SQLException sqlEx = (SQLException)var7;
                dae = this.transactionExceptionTranslator.translate("Hibernate transaction: " + ex.getMessage(), (String)null, sqlEx);
                if (dae != null) {
                    return dae;
                }
            }
        }

        if (ex instanceof JDBCConnectionException) {
            return new DataAccessResourceFailureException(ex.getMessage(), ex);
        }  //생략
         else if (ex instanceof StaleStateException) {
            return new ObjectOptimisticLockingFailureException(ex.getMessage(), ex);
    }