Question

I’m creating a function that will do a socket accept and return 3 vales
0=really bad error happen exit thread
1=ok talk to the connection
=something happen, do another accept (time out).

I see the IOException has a GetCause meths that returns a throwable object.
this throwable object has a get cause method that returns a throwable, which has a getcuase method returning a throwable, seems like this would go on forever, keep getting another throwable object.

How can I get the reason the exception ant off?????
I could use get reason and a bunch of string compares, but this does not seem to reliable.
Ted

int GetClient()
{
    try {
        server.setSoTimeout(5*1);  
        connection=server.accept();
    }
    catch(IOException ec)
    {
        System.out.println(Thread.currentThread()+":"+ec.getMessage()); 


        return 2; // for time out or something where we can try again
        // return a zero saying we must stop erra o bad

    }   
    return 1;
}

Answer 1

If you’re only interested in timeout exceptions then catch those exceptions separately. Most IO methods can potentially throw an IOException, but there are many different subclasses of IOException (which themselves have further subclasses) that you can catch and deal with separately.

eg.

try {
    conn = server.accept();
} catch (SocketTimeoutException e) {
    return 2;
} catch (IOException e) {
    // socket exception will not be recaught
    // even if return statement wasn't used
    return 0;
}
return 1;

The getCause method is provided as when exceptions are created they can be created with string message, but also the exception that may have caused this exception to be thrown. Thus allowing catchers of the exception to see the full detail of what caused the exception.

eg.

public double addNumbers(String a, String b) {

    try {
        double i = Double.parseDouble(a);
        double j = Double.parseDouble(b);
        return i + j;
    } catch (NullPointerException cause) {
        throw new IllegalArgumentException(
            "Arguments aren't allowed to be null", cause);
    } catch (NumberFormatException cause) {
        throw new IllegalArgumentException(
            "One or more arguments weren't numbers", cause);
    }
}

The above case is a little obtuse, but it demonstrates the principal that some exception may be caught (that maybe it might try to be recovered from) and then a new exception thrown with the original exception as the cause. Having a getCause method allows the caller to immediately see that the IllegalArgumentException was originally thrown in the addNumbers method (and that this is where the problem in the user code base is). However, by looking at the cause they will be able to see a more detailed message about by the argument was illegal (NumberFormatException includes the string that was trying to be parsed).