can ApplicationEventPublisher publish multi type event?

[magical-l]

I have some types of events to publish, and they have same superclass, as say:

class AEvent{
    A a;
}
class ACreatingEvent extends AEvent {}
class ACreatedEvent extends AEvent {}
class ADeletedEvent extends AEvent {}

now I'm going to publish them in my AService, since they are all AEvent, so I use a ApplicationEventPublisher<AEvent>

class AService{
    @Inject ApplicationEventPublisher<AEvent> publisher;

    public void create(){
        publisher.publishEvent(new ACreatingEvent());
        //......
        publisher.publishEvent(new ACreatedEvent());
    }

    public void delete(){
        publisher.publishEvent(new ADeletedEvent());
    }
}

but these events will not be send to my ApplicationEventListeners, because they are not ApplicationEventListener<AEvent> but ApplicationEventListener<ACreatingEvent>,ApplicationEventListener<ACreatedEvent>,ApplicationEventListener<ADeletedEvent>:

@EventListener void beforeACreating(ACreatingEvent e){}
@EventListener void afterACreated(ACreatedEvent e){}
@EventListener void afterADeleted(ADeletedEvent e){}

so I have to:

1. @Inject 3 publishers that matches the Event type one by one.
2. or all listeners' generic types use the superclass and then check the real subclass type inside the method.

both ways are bad...

am I miss something, or is there a better way?

[feavenwong]

I don't know if this is a better way...

@Singleton
public class EventPublisher {
  private final Map<Class<?>, ApplicationEventPublisher<?>> publishers;

  @SuppressWarnings("unchecked")
  public EventPublisher(ApplicationEventPublisher<ACreatingEvent> creatingEventPublisher,
                        ApplicationEventPublisher<ACreatedEvent> createdEventPublisher,
                        ApplicationEventPublisher<ADeletedEvent> deletedEventPublisher) {
    publishers = CollectionUtils.mapOf(
        ACreatingEvent.class, creatingEventPublisher,
        ACreatedEvent.class, createdEventPublisher,
        ADeletedEvent.class, deletedEventPublisher
    );
  }

  public <T> void publishEvent(T event) {
    @SuppressWarnings("unchecked")
    final ApplicationEventPublisher<T> publisher = (ApplicationEventPublisher<T>) publishers.get(event.getClass());
    publisher.publishEvent(event);
  }
}

You can manage them together, then just need @Inject EventPublisher eventPublisher