In ABAP Objects, triggering and handling an
event means that certain methods act as triggers and
trigger events, to which other methods - the handlers -
react. This means that the handler methods are executed when the event
This section contains
explains how to work with events in ABAP Objects. For precise details of
the relevant ABAP statements, refer to the corresponding keyword
documentation in the ABAP Editor.
To trigger an event, a class must
Declare the event in its declaration part
Trigger the event in one of its methods
You declare events in the declaration
part of a class or in an interface. To declare instance events, use the
EVENTS <evt> EXPORTING… VALUE(<ei>)
TYPE type [OPTIONAL]..
To declare static events, use the
Both statements have the same syntax.
When you declare an event, you can use
the EXPORTING addition to specify parameters that are passed to the
event handler. The parameters are always passed by value. Instance
events always contain the implicit parameter SENDER, which has the type
of a reference to the type or the interface in which the event is
An instance event in a class can be
triggered by any method in the class. Static events can be triggered by
any static method. To trigger an event in a method, use the following
RAISE EVENT <evt> EXPORTING… <ei>
= <f i>…
For each formal parameter <e
> that is not defined as optional, you must
pass a corresponding actual parameter <f
> in the EXPORTING addition. The
self-reference ME is automatically passed to the implicit parameter
Events are handled using special methods.
To handle an event, a method must
be defined as an event handler method for that event
be registered at runtime for the event.
Declaring Event Handler
Any class can contain event handler
methods for events from other classes. You can, of course, also define
event handler methods in the same class as the event itself. To declare
an event handler method, use the following statement:
METHODS <meth> FOR EVENT <evt> OF <cif>
for an instance method. For a static
method, use CLASS-METHODS instead of METHODS. <evt> is an event declared
in the class or interface <cif>.
The interface of an event handler method
may only contain formal parameters defined in the declaration of the
event <evt>. The attributes of the parameter are also adopted by the
event. The event handler method does not have to use all of the
parameters passed in the RAISE EVENT statement. If you want the implicit
parameter SENDER to be used as well, you must list it in the interface.
This parameter allows an instance event handler to access the trigger,
for example, to allow it to return results.
If you declare an event handler method in
a class, it means that the instances of the class or the class itself
are, in principle, able to handle an event <evt> triggered in a method.
Registering Event Handler
To allow an event handler method to react
to an event, you must determine at runtime the trigger to which it is to
react. You can do this with the following statement:
SET HANDLER… <hi>… [FOR]…
It links a list of handler methods with
corresponding trigger methods. There are four different types of event.
It can be
An instance event declared in a class
An instance event declared in an interface
A static event declared in a class
A static event declared in an interface
The syntax and effect of the SET HANDLER
depends on which of the four cases listed above applies.
For an instance event, you must use the
FOR addition to specify the instance for which you want to register the
handler. You can either specify a single instance as the trigger, using
a reference variable <ref>:
SET HANDLER… <hi>…FOR <ref>.
or you can register the handler for all
instances that can trigger the event:
SET HANDLER… <hi>…FOR ALL
The registration then applies even to
triggering instances that have not yet been created when you register
You cannot use the FOR addition for
SET HANDLER… <hi>…
The registration applies automatically to
the whole class, or to all of the classes that implement the interface
containing the static event. In the case of interfaces, the registration
also applies to classes that are not loaded until after the handler has
Timing of Event Handling
After the RAISE EVENT statement, all
registered handler methods are executed before the next statement is
processed (synchronous event handling). If a handler method itself
triggers events, its handler methods are executed before the original
handler method continues. To avoid the possibility of endless recursion,
events may currently only be nested 64 deep.
Handler methods are executed in the order
in which they were registered. Since event handlers are registered
dynamically, you should not assume that they will be processed in a
particular order. Instead, you should program as though all event
handlers will be executed simultaneously.