How to record exceptions masked by finally block exceptions in Java?
Please note that:
Problem: in Java, in try finally, if the try block throws an exception (named a), the control will reach the finally block (if there is no exception, it will also reach it, but it has no meaning in this problem) Then, if the finally block throws an exception (named B), exception a is suppressed or masked / swallowed, and exception B is propagated to the caller
Question: when an exception is compressed by another exception and the first exception is recorded / recorded, can I detect this in some way I spent too much time reasoning why I threw a special exception and didn't know what happened
Reason: the try finally blocks with problems are usually encoded in the library (today it is hibernate), so I can't modify them
Solution limitations: as I pointed out at the beginning, possible solutions should not be forwarded on Java 7, but on the other hand, they do not need to be production level (this will be a reward) AOP is the choice here
(please don't publish trivial answers like "developing with Java 7":)
Solution
I think the problem is that even with AOP, you can't intercept abnormal consumption processes With AOP, you can catch all created exceptions, but you don't know when they are consumed
For example:
try { ... } catch (Exception e) { log.boom("Ouchies happened here",e); }
Not every exception is thrown again
At some level, however, most exceptions are eventually thrown so that the caller can handle them
So, given that you may "leak" exceptions, the game is trying to find "leak" exceptions
With AOP, you can eliminate every exception when you create it (whether you do it at the exception level or you have to do it at a single level, I can't say – you're not familiar with AOP in practice)
Once you catch an exception when you create it, you start wrapping method calls through AOP When you do this, you can catch the exception thrown by the method
So, with some work, you know what exceptions are a) created and b) thrown when you return from the method If you traverse the exceptions caused by... That return exceptions from the method, you can remove these exceptions from the exceptions created by this method list The rest are loopholes
Ideally, after some analysis, you will be able to identify which are not thrown (but otherwise handled) and which are actually obscured by your finally block
It's not perfect, and I certainly won't use it in production (I just need to put a lot of work into all the competitive conditions such as recording. More debugging than I want to do, frankly) However, it may provide you with the information you are looking for, especially when used with caution in a small range of courses