An event type is considered assignable to a type variable if the event type is assignable to the upper bound, if any.

A parameterized event type is considered assignable to a raw observed event type if the raw types are identical.

A parameterized event type is considered assignable to a parameterized observed event type if they have identical raw type and for each parameter:

As usual, the qualifier type may have annotation members:

@Qualifier
@Target(PARAMETER)
@Retention(RUNTIME)
public @interface Role {
    String value();
}

Consider the following event:

public void login() {
    final User user = ...;
    loggedInEvent.fire( new LoggedInEvent(user), 
            new RoleQualifier() { public String value() { return user.getRole(); } );
}

Where RoleQualifier is an implementation of the qualifier type Role:

public abstract class RoleQualifier 
        extends AnnotationLiteral<Role> 
        implements Role {}

Then the following observer method will always be notified of the event:

public void afterLogin(@Observes LoggedInEvent event) { ... }

Whereas this observer method may or may not be notified, depending upon the value of user.getRole():

public void afterAdminLogin(@Observes @Role("admin") LoggedInEvent event) { ... }

As usual, the container uses equals() to compare event qualifier type member values.

An event parameter may have multiple qualifiers.

public void afterDocumentUpdatedByAdmin(@Observes @Updated @ByAdmin Document doc) { ... }

Then this observer method will only be notified if all the observed event qualifiers are specified when the event is fired:

documentEvent.fire( document, new UpdatedQualifier() {}, new ByAdminQualifier() {} );

Other, less specific, observers will also be notified of this event:

public void afterDocumentUpdated(@Observes @Updated Document doc) { ... }

public void afterDocumentEvent(@Observes Document doc) { ... }

The Event interface provides a method for firing events with a specified combination of type and qualifiers:

public interface Event<T> {
      
    public void fire(T event);
      
    public Event<T> select(Annotation... qualifiers);
    public <U extends T> Event<U> select(Class<U> subtype, Annotation... qualifiers);
    public <U extends T> Event<U> select(TypeLiteral<U> subtype, Annotation... qualifiers);
      
}

For an injected Event:

For example, this injected Event has specified type LoggedInEvent and specified qualifier @Any:

@Inject @Any Event<LoggedInEvent> any;

The select() method returns a child Event for a given specified type and additional specified qualifiers. If no specified type is given, the specified type is the same as the parent.

For example, this child Event has required type AdminLoggedInEvent and additional specified qualifier @Admin:

Event<AdminLoggedInEvent> admin = any.select( 
            AdminLoggedInEvent.class, 
            new AdminQualifier() );

If the specified type contains a type variable, an IllegalArgumentException is thrown.

If two instances of the same qualifier type are passed to select(), an IllegalArgumentException is thrown.

If an instance of an annotation that is not a qualifier type is passed to select(), an IllegalArgumentException is thrown.

The method fire() fires an event with the specified qualifiers and notifies observers, as defined by Section 10.5, “Observer notification”.

If the runtime type of the event object contains a type variable, an IllegalArgumentException is thrown.

The container must provide a built-in bean with:

The built-in implementation must be a passivation capable dependency, as defined in Section 6.6.2, “Passivation capable dependencies”.

Each observer method must have exactly one event parameter, of the same type as the event type it observes. When searching for observer methods for an event, the container considers the type and qualifiers of the event parameter.

If the event parameter does not explicitly declare any qualifier, the observer method observes events with no qualifier.

The event parameter type may contain a type variable or wildcard.

An observer method may be declared by annotating a parameter @javax.enterprise.event.Observes. That parameter is the event parameter. The declared type of the parameter is the observed event type.

public void afterLogin(@Observes LoggedInEvent event) { ... }

If a method has more than one parameter annotated @Observes, the container automatically detects the problem and treats it as a definition error.

Observed event qualifiers may be declared by annotating the event parameter:

public void afterLogin(@Observes @Admin LoggedInEvent event) { ... }

If an observer method is annotated @Produces or @Inject or has a parameter annotated @Disposes, the container automatically detects the problem and treats it as a definition error.

If a non-static method of a session bean class has a parameter annotated @Observes, and the method is not a business method of the EJB, the container automatically detects the problem and treats it as a definition error.

Interceptors and decorators may not declare observer methods. If an interceptor or decorator has a method with a parameter annotated @Observes, the container automatically detects the problem and treats it as a definition error.

In addition to the event parameter, observer methods may declare additional parameters, which may declare qualifiers. These additional parameters are injection points.

public void afterLogin(@Observes LoggedInEvent event, @Manager User user, Logger log) { ... }

A conditional observer method is an observer method which is notified of an event only if an instance of the bean that defines the observer method already exists in the current context.

A conditional observer method may be declared by specifying receive=IF_EXISTS.

public void refreshOnDocumentUpdate(@Observes(receive=IF_EXISTS) @Updated Document doc) { ... }

Beans with scope @Dependent may not have conditional observer methods. If a bean with scope @Dependent has an observer method declared receive=IF_EXISTS, the container automatically detects the problem and treats it as a definition error.

The enumeration javax.enterprise.event.Reception identifies the possible values of receive:

public enum Reception { IF_EXISTS, ALWAYS }

Transactional observer methods are observer methods which receive event notifications during the before or after completion phase of the transaction in which the event was fired. If no transaction is in progress when the event is fired, they are notified at the same time as other observers.

The enumeration javax.enterprise.event.TransactionPhase identifies the kind of transactional observer method:

public enum TransactionPhase {
    IN_PROGRESS,
    BEFORE_COMPLETION,
    AFTER_COMPLETION,
    AFTER_FAILURE,
    AFTER_SUCCESS
}

A transactional observer method may be declared by specifying any value other than IN_PROGRESS for during:

void onDocumentUpdate(@Observes(during=AFTER_SUCCESS) @Updated Document doc) { ... }

The transaction context, client security context and lifecycle contexts active when an observer method is invoked depend upon what kind of observer method it is.

Of course, the transaction and security contexts for a business method of a session bean also depend upon the transaction attribute and @RunAs descriptor, if any.