Exception handling

[Jim Vamvakitis]

Could somoene help by showing me how to handle a collection of exceptions, I have a JMS service that I do batch call of 50 and each one that does not go through an exception message is thrown. I have to execute the batch process and at the end I throw an exception that has the global exceptions caught. Any idea or help would be appreciated. Thanks.

[Tony Morris]

Pass a callback to whatever it is that does whatever you're doing.
One of these for example:

interface ExceptionHandler
{
    void handle(Throwable t) throws NullPointerException;
}

[bob morkos]

Could you provide details. I dont think this solution would be ideal. Maybe I don't understand, please elaborate.

Originally posted by Tony Morris:
Pass a callback to whatever it is that does whatever you're doing.
One of these for example:

interface ExceptionHandler
{
    void handle(Throwable t) throws NullPointerException;
}

[Paul Clapham]

Do you mean you have

public void handle(Collection<Exception> errors) {
  // I don't know what to do here
}

or do you mean you don't know how to create a collection of exceptions, or what?

[jiju ka]

interface ExceptionHandler
{
void handle(Throwable t) throws NullPointerException;
}

By using throws can you convert an unchecked exception to checked? You can't. Wherever there is a '.' there are chances of NullPointerException. Unchecked exceptions are easy to prevent than "overcome after letting it happen"

I will suggest (Below is something very crude, you may refine it for maintainability and flexibility)

exceptionCollection = ..; //prefers an ordered collection or FIFO so that exceptions can be chnologically handled.
try
{
//run batch
run(); //collect exceptions while running
}
finally
{
handleExceptions();
}

run()
{
try
{
//for each
}
catch(Throwable t)
{
exceptionCollection.add(t);
if (!canContinue(t))
{
releaseResources();
terminate();
}
}
}

handleException()
{
for(Iterator iter= exceptionCollection.iterator;...;..)
{
Throwable th = iter.next();
log(ERROR, th); //or whatever you want to do
}
}

While analyzing exceptions on a batch you may find time at which exception occured is a factor. Ex. An external system may be down at 8:00PM. In this case your Exception could mark the time of ExceptionOccurance too

Another suggestion...

try
{
//run batch
run(); //collect exceptions while running
}
finally
{
ReleaseResources();
}

run()
{
try
{
//for each transaction
}
catch(Throwable t)
{
handleException();
}
}

handleException()
{
log(ERROR, th); //or whatever you want to do
}

I like the second solution better than first one. In the second one if a deadlock happens or jvm terminates (ex: out of memmory), still I got some exceptions logged and predict the state of data from the log.
[ December 19, 2005: Message edited by: jiju ka ]

[Tony Morris]

And so we digress...

Do you mean you have

    public void handle(Collection<Exception> errors) {
      // I don't know what to do here
    }

or do you mean you don't know how to create a collection of exceptions, or what?

No I do not mean that, and yes I know how to create a collection of exceptions. I would certainly not recommend passing a java.util.Collection to any method, ever, but that's another story.

By using throws can you convert an unchecked exception to checked? You can't. Wherever there is a '.' there are chances of NullPointerException. Unchecked exceptions are easy to prevent than "overcome after letting it happen"

No, the throws clause is merely part of the contract. All methods that accept one or more reference type should throw NullPointerException - this is the optimal workaround to the flawed existence of null (even the Gods that the sheep faithfully follow will agree with this, so there should be a lot of literature on it by now).

To the point, all you are doing is passing a single instance to "whatever it is that might throw an exception" so that it can be called back on in the event of an exception. The downside is that you lose definite assignment semantics - this can remedied by the handle method returning a java.lang.RuntimeException and the implementation that calls back can declare to throw it.

Perhaps an example:

import java.io.InputStream;
import java.io.IOException;
import java.io.ByteArrayInputStream;
 
interface ExceptionHandler
{
    /**
     * Handles the given exception.
     * 
     * @param t The exception to handle.
     * @throws NullPointerException <code>if(t == null)</code>.
     */
    void handle(Throwable t) throws NullPointerException;
}
 
interface InputStreamEof
{
    /**
     * Reads the given <tt>InputStream until</tt> end of file.
     * 
     * @param in The <tt>InputStream</tt> to read until end of file.
     * @param eh The exception handler to use should an exception occur.
     * @return The number of reads.
     * @throws NullPointerException <code>if(in == null || eh == null)</code>.
     */
    int eof(InputStream in, ExceptionHandler eh) throws NullPointerException;
}
 
final class InputStreamEofImpl
{
    private static final InputStreamEof x;
 
    static
    {
        x = new InputStreamEof()
        {
            public int eof(final InputStream in, final ExceptionHandler eh) throws NullPointerException
            {
                if(in == null || eh == null)
                {
                    throw new NullPointerException();
                }
                else
                {
                    int read = 0;
 
                    try
                    {
                        while(in.read() != -1)
                        {
                            read++;
                        }
                        
                        return read;
                    }
                    catch(IOException e)
                    {
                        eh.handle(e);
                        // Problem: lack of definite assignment forces the exceeding of scope or a "dummy" value.
                        // Solution: Declare ExceptionHandler.handle to return a java.lang.RuntimeException.
                        // throw eh.handle(e);
                        // Since we don't have that, we'll return a dummy value to "make the compiler happy", oh well.
                        return 0;
                    }
                }
            }
        };
    }
 
    private InputStreamEofImpl() throws UnsupportedOperationException
    {
        throw new UnsupportedOperationException();
    }
 
    public static InputStreamEof getInputStreamEof()
    {
        return x;
    }
}
 
final class Main
{
    private Main() throws UnsupportedOperationException
    {
        throw new UnsupportedOperationException();
    }
    
    public static void main(final String[] args) throws NullPointerException
    {
        if(args == null)
        {
            throw new NullPointerException();
        }
        else
        {
            final ExceptionHandler eh = new ExceptionHandler()
            {
                public void handle(final Throwable t) throws NullPointerException
                {
                    if(t == null)
                    {
                        throw new NullPointerException();
                    }
                    else
                    {
                        System.err.println("Do whatever you want, but I'll just print the stack to stderr");
                        t.printStackTrace();
                    }
                }
            };
            
            final InputStreamEof ise = InputStreamEofImpl.getInputStreamEof();
            final InputStream in = new ByteArrayInputStream(new byte[]{7, 8, 9});
            ise.eof(in, eh);
        }                
    }
}

[Jim Yingst]

I believe Paul Clapham meant to direct his question to Jim Vamvakitis, not to Tony. At least, Paul's question matched what I was wondering about Jim V's post. Might be useful to get Jim V to clarify what he really meant...

[Paul Clapham]

Originally posted by Jim Yingst:
I believe Paul Clapham meant to direct his question to Jim Vamvakitis, not to Tony.

Yes, that's correct. Apologies for not being clear.

[Tony Morris]

OK sorry, my mistake.