| |
Abstract
JAIN SLEE and SIP Servlets are both standards defined through the Java Community Process that address the development of applications.
Both standards define a container based model for applications, define how applications may be built and deployed in the respective containers
and the services and features supplied by the containers.
In this paper objectives of the two standards are outlined. A number of application characteristics are then identified which are
subsequently used to compare and contrasts JAIN SLEE and SIP Servlets.
JAIN SLEE and SIP Servlet
JAIN SLEE defines an application environment suited for network orientated applications. It defines a protocol agnostic,
component and object orientated and transacted programming model. A JAIN SLEE is adapted to use a partcular resource by a
resource adaptor, so the SLEE is inherently extensible. The nature of the programming model and the services that the JAIN
SLEE provides have been designed to address typical requirements of tier one carriers.
SIP Servlets defines a container based model that is an extension of the well understood Servlet model. It was designed to simplify
the development of SIP based applications and thereby enhance the adoption of the SIP protocol.
Comparison
A number of features of applications may be considered in order to compare and contrast these two models to better understand the
benefits of each and how they might best be used. The following concepts may be considered:
- Application Architecture: The way in the business logic of an application is structured
- Application State: The way application state may be represented, accessed and protected
- Concurrency Control: The way the multiple threads of execution may be controlled
- Facilties Availible to Applications: Ultilities made availible to applications by the container
- Availibility Mechanisms: How the features and concepts of the model may be leveraged to support continuous availibity
- Management: The mechanisms provided by the container to manage applications and the container itself
SIP Servlets |
JAIN SLEE |
Application Architecture |
|
Based on HTTP Servlets
Unit of application logic is the Servlet
No standard model for composition and reuse
|
Component based, Object Orientated architecture
Unit of logic is the Service Building Block (SBB)
Support for composition and reuse
|
Application State |
|
Servlets are stateless
Shared state may be stored in a separate session object as name value (String, Object) pairs
Shared state is visible to all Servlets with access to the session
|
SBBs may be stateful (or stateless)
SBB state is private, type safe, transacted and a property of the SBB itself (i.e. an SBB is an object)
Shared state may be stored in a separate ActivityContext via a type safe interface
Access to shared state may be specified at deploy time
|
Concurrency Control |
Application managed only, i.e. use of Java monitors |
System Managed, i.e. isolation of concurrent transactions |
Protocol Support |
SIP and HTTP |
Protocol agnostic
Can be extended to support additional protocols and external resources
Consistent event model, regardless of protocol/resource
|
Facilities (Utilities for Applications) |
Timer |
Timer Trace Alarm Statistics and Usage Profiles |
Availability Mechanisms |
|
Container managed state (session object) that can be replicated
No transaction context for SIP message processing
Non transacted state operations
Facilities are non transacted
No defined failure model
|
Container managed state (SBB CMP, ActivityContext, facility state etc) that can be replicated
Transaction context for event delivery
Container managed state operations are transacted
Facilities, e.g. timers, are transacted
Well defined and understood failure model via transactions
|
Management |
No standard management mechanisms defined |
Standard management interfaces are defined based on JMX (Java for Management Extensions)
Independent of Management protocol
Interface for managing applications, including life cycle, upgrades, profiles, tracing etc
Interface for managing SLEE life cycle
|
Summary
JAIN SLEE is a more complex specification that SIP Servlets.
JAIN SLEE has standardised the High Availability and Fault Tolerance mechanisms of the programming model and of the lifecycle of the application.
SIP Servlets is a programming model, JAIN SLEE is an application environment.
|
|
