Adhere to expected Exception Handler invocation order

[smcvb]

eBy using the @ExceptionHandler, a method becomes a special type of MessageHandlerInterceptor, specifically to catch thrown exceptions from message handlers.
As such, an exception handler is "just another message handler" from Axon Framework's perspective.

A part of being a regular message handler is the ordering implied on them through the HandlerComparator.
This comparator gives precedence on MessageHandlingMembers based on (1) priority, (2) message payloadType hierarchy, (3) parameter count, and (4) method name.

For any other interceptor, this means the defined priority by the HandlerComporator dictates the interceptor invocation order.
When we're dealing with an exception handler, the method is registered based on this order.
When then an exception is thrown, the last registered handler is invoked first.

This thus causes @ExceptionHandler annotated methods to be invoked in the inverse order.

To resolve this predicament, this pull request introduces the ReversedOrder marker interface.
Components can implement this interface, so that a Comparator or Comparable implementation can impose a reverse ordering on these components.
Furthermore, the HandlerComparator checks whether the objects compared on both implement this interface.
If they do, steps 2 through 4 are inverted.

Through this, the @ExceptionHandler order can be adjusted by letting the ResultHandlingInterceptorMember implement the ReversedOrder interface.

[abuijze]

I wrote a little test to verify whether the outcome is consistent. Since the "expected" value here isn't exactly what we'd expect, I didn't commit the test as part of the PR.

    @RepeatedTest(100)
    void handlerOrderIsDeterministic() {
        List<MessageHandlingMember<?>> handlers = new ArrayList<>(Arrays.asList(stringHandler, objectHandler, longHandler, numberHandler, priorityHandler, stringHandlerReversedOrder, objectHandlerReversedOrder));
        Collections.shuffle(handlers, ThreadLocalRandom.current());

        handlers.sort(testSubject);

        List<MessageHandlingMember<?>> expected = Arrays.asList(priorityHandler, objectHandlerReversedOrder, longHandler, numberHandler, stringHandler, objectHandler, stringHandlerReversedOrder);
        assertEquals(expected, handlers);
    }

The actual order I would recommend for this is:
List<MessageHandlingMember<?>> expected = Arrays.asList(objectHandlerReversedOrder, stringHandlerReversedOrder, priorityHandler, longHandler, numberHandler, stringHandler, objectHandler);
Although the numberHandler and stringHandler have equal precedence rules, since they are both direct descendants of Object. Either one first works, as long as it is deterministic.

[gklijs]

Looks good to me 👍

[CodeDrivenMitch]

Took me a while to wrap my head around the changes, but it looks good. I'm approving.

[smcvb]

I like the adjustments you've made, @abuijze 👍
Thanks for the effort!

Allard made adjustments to accommodate for his review remarks.

[sonarcloud]

Kudos, SonarCloud Quality Gate passed!   

0 Bugs
0 Vulnerabilities
0 Security Hotspots
0 Code Smells

96.0% Coverage
0.0% Duplication