thrift-user mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Craig Artley <>
Subject C++ and Java servers differ in their handling of standard exceptions‏
Date Mon, 21 May 2012 13:55:13 GMT

How come the C++ and Java servers differ in their handling of standard exceptions?
The generated C++ service code catches std::exception and turns it into a TApplicationException
and passes it back to the client.  In contrast, the generated Java service code does nothing
like this. In particular, if a Java server encounters a RuntimeException, it is not handled.
 The result is the client gets a cryptic TConnectionException with no indication of the problem.
Shouldn't the generated Java server code behave more like the C++ server?
You can see this in the code generated for the tutorial example.  If you look at the generated
Calculator.cpp code for the C++ server, you will see that every process_* method includes
catch blocks for std::exception. These catch blocks do the conversion to TApplicationException.
 But when you look at the Java server code in, the getResult methods don't
have any such catch blocks for RuntimeExceptions.
The upshot is that for Java servers to throw useful RuntimeExceptions like IllegalArgumentException
requires the user to declare that every method throws a custom exception, then wrap every
method implementation with boilerplate to catch RuntimeExceptions and translate them to the
custom exception. This is onerous and error prone. Since the C++ server does it automatically,
I think the Java server should as well.
Thrift-378 seems to address this issue. The conclusion is that it was fixed. However, it obviously
is not.

View raw message