Java异常在被捕获后似乎被重新抛出

Question

I have run into a scenario I don't understand. I have the following web service (using a bunch of pseudo code below).

In my transaction Manager class:

Response HandleRequest(List<Object> myStuff) throws RemoteException   
{ 
    Map<Object, String> problemMap = dataManager.saveMyStuff(myStuff)

    //Nothing here gets executed because HibernateSystemExeption was mysteriously (re)thrown
    log.warn("Step 5");
    if(problemMap.size() > 0)
    {
         //Put problem objects and error messages in response
         return response;
    }
}

Then in my DataManager class I have:

Map<Object, String> saveMyStuff(List<Object> mystuff) 
{
    Session sess = getSession();
    Transaction tx = sess.beginTransaction();
    boolean successful = true;

    Map<Object, String> problems = new HashMap<Object, String>();
    for(Object o : mystuff)
    {
        try
        {
            //Do some hibernate stuff here that throws a HibernateSystemException
        }
        catch(Exception e)
        {
            log.warn("Caught an exeption!", e);
            successful = false;
            log.warn("Step 1");
            problems.put(o, "Couldn't Store object");
            log.warn("Step 2");
        }
    }

    log.warn("Step 3");
    try
    {
        if(successful)
            tx.commit;
       else
            tx.rollback();
    }
    catch(Exception e)
    {
        log.warn("Another Exception caught!", e);
    }

    log.warn("Step 4");
    return problems;
}

What happens is the exception is successfully caught in the datamanager and I see it in the log file. The code proceeds to the return statement. BUT, when it returns from the datamanager I get the SAME exception in the Transaction Manager as if it was never caught by the datamanager and that exception is passed back to the user raw as a remote exception instead of the response. Nothing in the transaction manager after the call to saveMyStuff gets executed. It's as if the exception remains on the stack until the method returns and then gets thrown again even though it's been handled in the datamanager. Has anyone seen anything like this before, or know what might be happening?

EDIT: After a little more experimenting it seems the issue has to do with the fact that it is a HibernateSystemException. If I throw a generic Exception as a test the code works as I would expect. So what is it about the HibernateSystemException that causes this strange behavior?

EDIT 2: I've done as suggested and wrapped the transaction commit/rollback in a try/catch. The exception still makes it back to the user. I've also added debug print statements. And in the log I see steps 1-4 printed but not 5. I also do NOT see an exception being caught from the transaction commit/rollback block.

Answer 1

What you describe doesn't match the Java Exception Handling logic. Therefore, something different is happening, eg the exception may get thrown by tx.rollback(). Try including also the rollback in a try-catch and handle the Exception there.

Answer 2

My previous answer was not right so there goes the new code. I suggest another try catch block to make sure there's no second exception thrown.

Map<Object, String> saveMyStuff(List<Object> mystuff) 
{
    Session sess = getSession();
    Transaction tx = sess.beginTransaction();
    boolean successful = true;

    Map<Object, String> problems = new HashMap<Object, String>();
    for(Object o : mystuff)
    {
        try
        {
            //Do some hibernate stuff here that throws a HibernateSystemException
        }
        catch(Exception e)
        {
            log.warn("Caught an exeption!", e);
            successful = false;
            problems.put(o, "Couldn't Store object");
        }
    }



  try
        {
            if(successful)
               tx.commit;
             else
               tx.rollback();
        }
        catch(Exception e)
        {
            log.warn("Caught an exeption!", e);
            problems.put(o, "Couldn't Store object");
        }

    return problems;
}

Answer 3

Okay, I found the problem. Since I was calling getSession instead of openSession the session was being implicitly flushed when the method returns. The act of flushing the session caused the second exception to be thrown. I confirmed this by explicitly flushing the session before returning and surrounding that in a try/catch. That caught the exception but it was still thrown when the session was flushed again upon return. The ultimate fix was to call openSession AND surround the session flush with a try catch block.

DataManager class:

Map<Object, String> saveMyStuff(List<Object> mystuff) 
{
    Session sess = getSessionFactory.openSession();
    Transaction tx = sess.beginTransaction();
    boolean successful = true;

    Map<Object, String> problems = new HashMap<Object, String>();
    for(Object o : mystuff)
    {
        try
        {
            //Do some hibernate stuff here that throws a HibernateSystemException
        }
        catch(Exception e)
        {
            log.warn("Caught an exeption!", e);
            successful = false;
            problems.put(o, "Couldn't Store object");
        }
    }

    try
    {
       if(successful)
            tx.commit;
       else
            tx.rollback();

        sess.flush();
    }
    catch(Exception e)
    {
        log.warn("Another Exception caught!", e);
    }
    finally
    {
        sess.close();
    }

    return problems;
}

Thank you everyone for all your help!