Develop asynchronous scopes
Asynchronous scopes are units of scoping that comprise a set of alarms, subsystem monitors, and child asynchronous scopes. We can create asynchronous scopes, starting with the parent.
Use asynchronous scopes can involve some or all of the following steps:
- Create asynchronous scopes. Create the parent asynchronous scope object by using a unique parameter name that calls the AsynchScopeManager.createAsynchScope() method. We can store properties in an asynchronous scope object. This storage provides Java 2 Enterprise Edition (J2EE) applications with a way to store a non-serializable state that otherwise cannot be stored in a session bean. You also can create child asynchronous scopes, which is useful for scoping data beneath the parent.
- Listen for alarm notifications
- Create a listener object by implementing the AlarmListener interface. For more information, refer to the AlarmListener interface in the generated API documentation.
- Supply this object to the AlarmManager.create() method, as the target for the alarm. The create() method takes the following parameters:
- Target for the alarm
- The target on which the fired() method is called when the alarm is fired.
- Context
- The context object for the alarm. This object is useful for supplying alarm-specific data to the listener and supports a single listener for multiple alarms.
- Interval
- The number of milliseconds before the alarm fires.
After the specified interval, the alarm fires and the fired() method of the listener is called with the firing alarm as a parameter. The alarm object is returned. By calling methods on this object, we can cancel or reschedule the alarm.
- Monitor remote systems.
The subsystem monitor configures alarms to track the heartbeat status of the remote system. When the ping() method is called, the alarms are reset. If an alarm fires, the ping() method is not called; that is, the application did not receive a heartbeat from the monitored subsystem.
- Implement a mechanism for detecting messages sent from the remote system. For example, publish and subscribe messaging.
- Create a subsystem manager object by calling the SubsystemMonitorManager.create() method with the following parameters:
- Name
- Each subsystem monitor must have a unique name.
- Heartbeat interval
- The expected interval, in milliseconds, between heartbeats.
- Missed heart beats until stale or suspect
- The number of heartbeats that can be missed before the subsystem is marked as stale.
- Missed heart beats until dead
- The number of heartbeats that can be missed before the system is marked as dead.
- Create an object that implements the SubsystemMonitorEvents interface. For more information, see the SubsystemMonitorEvents in the generated API documentation.
- Add an instance of this object to the subsystem monitor using the SubsystemMonitor.addListener() method.
- Whenever a heartbeat message arrives from the remote system, call the SubsystemMonitor ping() method.
Example
Asynchronous scopes are useful in stateful server applications. An application can have a startup bean that creates an asynchronous scope on a named work manager. The application also might create subsystem monitors to monitor the health of any remote systems on which the application is dependent.
When a client attaches to the server, the application creates a child asynchronous scope that is owned by the application asynchronous scope for the client and named using the client ID. A subsystem monitor for monitoring the client might be created on the client asynchronous scope. If the client times out, a callback can clean up the client state on the server. Callbacks can be attached to the application subsystem monitors, on behalf of the client. When a remote system becomes unavailable, the client code in the server is notified and an event is sent to the client to warn that a critical remote system has failed. For example, the failure might be a data feed in an electronic trading application.
- Asynchronous scopes
An asynchronous scope (AsynchScope object) is a unit of scoping provided for use with asynchronous beans.
- Alarms
An alarm runs JEE context-aware code at a given time interval. Alarm objects are fine-grained, nonpersistent, transient, and can fire at millisecond intervals.
- Subsystem monitors
A subsystem monitor is an object that monitors the health of a remote system. It uses an event source to inform all registered listeners of the health of the system.
- Asynchronous scopes: Dynamic message bean scenario
JEE (Java EE) now supports message-driven beans, but the beans are static. This scenario provides information about how to set up the environment to enable the dynamic message bean.
Programming Interfaces APIs