deltaspike-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Thomas Herzog (JIRA)" <>
Subject [jira] [Commented] (DELTASPIKE-218) ExceptionHandler observer chain is broken with same ordinal
Date Thu, 05 Jul 2012 19:04:33 GMT


Thomas Herzog commented on DELTASPIKE-218:

I assumed that if there are multiple handlers for the same type then they get invoked in an
non-deterministic order as long as the event gets not marked as handled, as the user doc says.
That is exactly the behavior we need.
What do i need to do, that you can determine the different handles ?

How we use it now:
abstract class AbstractExceptionHandler<E extends Throwable, M extends Annotation>()

     abstract void handle(ExceptionEvent<E> event);

     private handleException(ExceptionEvent<E> event) { ... }

     abstract Class<M> getExceptionMessageAnnotation();

class CoreExceptionHandler()<CoreException, CoreExceptionMessage>{

     void handle(@Handles ExceptionEvent<CoreException> event) { ... }

     CoreExceptionMessage getExceptionMessageAnnotation(){
           return CoreExceptionMessage.class;

class ModuleExceptionHandler()<CoreException, ModuleExceptionMessage>{

     void handle(@Handles ExceptionEvent<CoreException> event) { ... }

     ModuleExceptionMessage getExceptionMessageAnnotation(){
           return ModuleExceptionMessage.class;
> ExceptionHandler observer chain is broken with same ordinal
> -----------------------------------------------------------
>                 Key: DELTASPIKE-218
>                 URL:
>             Project: DeltaSpike
>          Issue Type: Bug
>          Components: ExceptionControl-Module
>    Affects Versions: 0.2-incubating
>         Environment: Websphere
> Myfaces 2.1.1
> Myfaces-Codi 1.0.4
> Primefaces 3.1
>            Reporter: Thomas Herzog
>            Assignee: Jason Porter
>             Fix For: 0.3-incubating
> When multiple observer methods are handling the same ExceptionEvent<T extends Throwable>
with same exception type and do have the same ordinal or no one defined, then only one observer
method gets invoked.
> This observer methods does not mark the event as handled, but the next ones do not get
> With ordinal defined, it works as expected.
> Example:
> -------------
> {code}
> @CoreExceptionMessage(...)
> class CoreException {...}
> @ModuleExceptionMessage(...)
> class ModuleException extends CoreException {...}
> handleCore void (@Handles ExceptionEvent<CoreException> event)
> { // Handles CoreException instances, determined via @CoreExceptionMessage annotation...}
> handleModule void  (@Handles ExceptionEvent<CoreException> event) 
> { // Handles ModuleException instances, determined via @ModuleExceptionMessage annotation...}
> {code}
> If annotation is not found the event gets not handled, so one of the next handlers shall
do handle it.
> We do have an AbstractExceptionHandler which defines common work to do, and subtypes
providing the @Handles annotated observer method and necessary data for the AbstractExceptionHandler
such as annotation class.

This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators:!default.jspa
For more information on JIRA, see:


View raw message