This chapter explores the current province of package constituent engineering. It includes a description of constituents, and a comparing between constituents, categories and faculties. Then, some definitions of a constituent are presented, followed by features and belongingss of a constituent. Assorted component theoretical accounts are described and compared.
2.1 What is a Software Component
In recent old ages, the progress of calculating has increased significantly due to faster hardware, better package development and decreased cost. Better web substructure besides contributes to better internet-based engineerings and services. Calculating processing can be executed anyplace at anytime [ 47 ] . Distributed systems connect computing machines through webs, and supply support for inter-process communicating, distant supplication, calling services, etc [ 29, 36, 64 ] . This state of affairs supports the possibility of big graduated table package development. A big graduated table package development normally involves many faculties, many coders and over a long clip [ 11, 19, 26, 45 ] . Development of large-scale applications utilizing traditional techniques tends to increase the development cost, development clip, and resources to be deployed [ 11, 26 ] . The debut of object-oriented engineering has improved the flexibleness and maintainability of the codification [ 9, 51 ] . By stressing modularity, object-oriented engineering helps analysis, design, scheduling and proving stages [ 9, 48 ] . The nature of object-oriented engineering focuses on procedure abstraction, and on how the package is designed and implemented. At every stage of the development, object representations have common theoretical accounts, which help development faster [ 9 ] .
When package development gets bigger in graduated table, so benefits of object-oriented engineering are no longer plenty, and constituent engineering is expected to supplement it [ 13 ] . Udell even predicted the weakness of object-oriented engineering and the success of component engineering [ 68 ] . Object-oriented engineering is considered by some to be excessively theoretical and non practical plenty [ 68 ] . It does non include the thought of independence and deployment and it is largely implemented in individual massive applications. However component engineering shows the possibility of deriving economic and market advantage [ 66 ] .
The nature of constituent engineering focuses more on execution and deployment. A package constituent can be implemented in a traditional linguistic communication such as C [ 27 ] or an object-oriented linguistic communication such as C++ [ 62 ] or Java [ 3 ] . The deployment procedure is comparatively consecutive frontward. A piece of constituent can be plugged into an application and played the expected functionalities [ 65 ] . Expected benefits for package developers are:
1. Immediate handiness [ 7, 11, 52 ] .
2. Reduced development cost and clip to market [ 7, 11, 20, 66 ]
3. Improvement in dependability, maintainability, evolvability, interoperability and public presentation [ 20 ] .
4. Rich functionality, loosely used, dedicated support organisation, software/hardware independent [ 7 ]
5. Better complexness direction, thereby bettering the quality of solution [ 20 ] .
6. Better human resource use [ 20 ]
7. Higher reuse for future development [ 20 ] .
There are, nevertheless, some disadvantages with the debut of package constituent:
* Complexity issues [ 14, 16-18, 28, 30, 31, 35, 38, 57, 67 ] .
* Increase criticalness [ 38, 56 ] .
* Increase interaction among constituents [ 5, 30-32, 38, 50, 71 ] .
* Incompatible interaction behaviors [ 21 ] .
* Deadlocks and other package anomalousnesss within the system [ 64 ]
* Integration troubles, public presentation restraint, mutual exclusiveness among merchandises from different seller [ 12, 56 ]
* Black box proving on an incorporate constituents may present assorted public presentation and dependability factors [ 7, 56 ] ;
* New cost theoretical account for constituent based system [ 2 ] . The traditional cost theoretical account is non suited for constituent based system because of the difference in development features ;
* Vendor dependence, repeating care cost, unknown dependability, repeating care cost [ 7 ]
* Need for new procedures development of constituent based package [ 15 ] .
Component Based Software Engineering ( CBSE ) [ 13, 25 ] aids in the procedure of constructing big package based on constituent engineering. Reduced cost and shorter turn around clip for the package development are two of the aims for Component Based Software Engineering [ 66 ] .
Szyperki [ 66 ] defines a package constituent as follows:
“ A package constituent is a unit of composing with contractually specified interfaces and expressed context dependencies merely. A package constituent can be deployed independently and is capable to composing by 3rd parties ” .
In [ 65 ] , he farther adds that a package constituent should besides be “ a unit of versioning and replacing ” . As per definition a constituent is deployable, has a chiseled interface, and is maintainable.
To ease the usage of a constituent, a set of interfaces is offered to link with other constituents or parts of a package system [ 66 ] . Therefore an application can be built by stop uping constituents into an application. A set of criterions is needed to wire the constituents ‘ interfaces. The bigger the application the more constituents are needed. In theory, there is no bound on how we will wire the constituents [ 37 ] .
Software constituents offer a new packaging technique to present package to the user. The packaging may include object-oriented or non-object-oriented beginning codification. The packaging wraps the codification and hides the codification inside informations from exterior. The functionalities are exposed via one or more interfaces. The interface can be an entrance or an outgoing interface. The incoming interface is called by other constituents, while the outgoing interface calls other constituents [ 22, 23, 39, 66 ] .
Developing constituent based package from heterogenous beginnings requires industry criterions and some of these include, JavaBeans from Sun Microsystems [ 63 ] , COM+/DCOM/.NET from Microsoft Corporation [ 33, 34 ] and CORBA Component Model ( CCM ) from the Object Management Group ( OMG ) [ 42-44 ] . In pattern, systems designed utilizing even the known criterions still do non incorporate good [ 41 ] . The freshly developed Vienna Component Framework [ 41 ] enables composition across different constituent criterions, and hence it is hoped that it will work out some of the integrating jobs.
2.2 Components versus Classes versus Faculties
The footings constituent, faculty and category are normally and bewilderingly used interchangeably in package development. Some similarities exist in these three signifiers. The physical signifiers of the three look the same as each are built from beginning codification. Classs have belongingss and methods likewise to constituents. Components have belongingss and methods excessively, which are offered through their interfaces. Components can be developed utilizing a set of categories. However there are clear differentiations between package categories and package constituents [ 60, 66 ] :
* “ Components are deployable entities ” .
To deploy categories, one has to roll up the category ‘ codification, while constituents can be plugged into an application.
* “ Components do non specify types ” .
Classs describe an abstract information type, while a constituent has no type since it is an case already.
* “ Component executions are non crystalline ” .
The beginning codification in categories can be modified by their users ; nevertheless constituents are largely delivered in double stars, which prevent alteration of the codification by their users. A component user merely needs a elaborate description of the interface to utilize the constituent.
* “ Components are language-independent ”
Classs can merely pass on with other categories that use the same linguistic communication. However to implement a constituent, one can utilize different linguistic communications, and so the component-to-component interaction occurs via chiseled interfaces.
* “ Components are standardized ” .
Classs are non implemented utilizing specific criterions or theoretical accounts, but execution of constituents should follow a specific criterion or theoretical account, illustration of such criterions or theoretical accounts are.NET, EJB or CORBA.
A category represents a plan unit that encapsulates category properties and methods. A category can be viewed as a reclaimable constituent without deployment support. However, there are some similarities in belongingss such individuality, encapsulation, reuse, polymorphism and composing. Classs are non composite edifice blocks because they have no standard theoretical account and mechanism to back up interaction, packaging and deployment [ 66 ] .
The term faculty has been used before the term category was invented [ 46, 58 ] . Faculties can be formed from files, subprograms, library maps, subsystems or even multiple categories [ 61, 66 ] . Faculties can be implemented in different linguistic communications. Some illustrations of linguistic communications that implement faculties are: Modula2, Ada ( faculties are called bundles ) , Eiffel, Oberon, Modul-3, Component Pascal, Java, Smalltalk.
Faculty has been a standard term for conventional development which support the construct of modularity [ 47, 59 ] . There are differences between categories and faculties such as categories need to be instantiated to make objects, heritage and polymorphism construct known merely to categories. There are, nevertheless, some similarities between them, such as both can conceal the inside informations of execution from the user or public position [ 64 ] .
Faculties are developed to back up some functionalities of an application. Software faculties are designed to be tightly coupled and well-structured, so that they are easy to utilize and incorporate within the system [ 64 ] . In developing package faculties, interaction and composing is non the chief focal point. Hence package faculties may exhibit deficiency of interoperability. Packaging and deployment attacks are non implemented as portion of faculty development, so they can non be deployed independently [ 66 ] . Software faculties are developed for specific environments ; therefore it is difficult to implement them on different context of environment. Component developers build package constituents with the purpose to bring forth a extremely reclaimable merchandise with a chiseled contract, well-packaged and deployable. It should be possible to utilize the result across different the merchandise lines and environment [ 66 ] .
Some important differences between faculties and constituents are:
* Faculties can non be configured, unless the codification is modified and compiled. Components may be configured without recompiling the codification [ 66 ] .
* Faculties can be compiled to utilize planetary inactive variables to expose some discernible provinces. Components do non let discernible province [ 66 ] .
By analyzing differences and similarities between faculties and constituents, faculties can be viewed as minimum constituents [ 66 ] , or we can state a faculty can go a constituent, nevertheless a constituent is non ever a faculty.
2.3 Software Component Definitions
A alleged constituent follows the package technology rule of uniting maps and properties in the same container [ 66 ] . The construct has been adopted in object engineering ; nevertheless there are major drawbacks when people try to implement categories and objects in the existent universe, such as the deficiency of independent execution and deployment inside informations [ 64, 68 ] . Component descriptions differ harmonizing to the developers who use the constituent [ 24, 49 ] . Pressman notes that there are three positions of constituent:
* Object-oriented position ( a set of categories build a constituent )
* Conventional position ( functional elements that are combined in a faculty that offers a set of interfaces )
* Process-related positions ( focal points on the reuse of constituents and design form ) .
There are many writers who have attempted to specify the package component universe. Different writers give different positions about package constituents.
* Grady Booch in the Unified Modelling Language User Guide ; defined a constituent as: “ A logical and replaceable portion of a system that conforms to and provides the realisation of a set of interfaces. ” [ 10 ]
* The Object Management Group ( OMG ) defines a constituent as “ a modular deployable, and replaceable portion of a system that encapsulates execution and exposes a set of interfaces ” . This definition is based on CORBA execution [ 43 ] .
* Wang and Qian define a constituent as follows: “ A package constituent is a piece of self-contained, self-deployable computing machine codification with chiseled functionality and can be assembled with other constituents through its interface. ” [ 70 ]
* Brown and Wallnau cite the constituent definition from Philippe Krutchen of Rational Rose. The definition says a constituent is “ a nontrivial, about independent, and replaceable portion of a system that fulfills a clear map in the context of chiseled architecture ” . [ 13 ]
* Sametinger defines “ Reclaimable package constituents are self-contained, clearly identifiable pieces that describe and/or perform specific maps, have clear interfaces, appropriate certification, and a defined reuse position ” [ 52 ] .
* Heineman and Councill: A package constituent is “ a package component that conforms to a constituent theoretical account and can be independently deployed and composed without alteration harmonizing to a composing criterion. ” [ 25 ] . They further province that a component theoretical account identifies a set of criterions for interaction and composing.
* Szyperski defines: “ A package constituent is a unit of composing with contractually specified interfaces and expressed context dependencies merely. A package constituent can be deployed independently and is capable to composing by 3rd parties ” [ 64, 66 ]
* Gao et. Al. simplify the construct of package constituent into three types [ 20 ] :
1. A reclaimable faculty: “ an independent and deliverable package portion that encapsulates a functional specification and execution for reuse by 3rd party ” ,
2. A reclaimable constituent: “ an independent, deployable and replaceable package unit that is reclaimable by a 3rd party based on the unit ‘s specification, execution and chiseled contracted interfaces ” , and
3. A composite edifice block: “ A reclaimable constituent that is developed as a edifice portion to conform a chiseled constituent theoretical account and the attach toing composing criterions ”
The above definitions allow for constituents to be connected to any figure of other constituents utilizing the specified chiseled interfaces. Interaction between constituents is allowable merely through these interfaces [ 66 ] . The definitions imply that each constituent is clearly separated from its environment and other constituents, and a constituent is non partly deployed. Components have no relentless province so that transcripts can non be distinguished from the original.
Connections between constituents illustrate interactions between constituents. The interactions between constituents can be characterized by the usage of a constituent ‘s interface or through capturing or devouring other constituent ‘s events. In other words, interaction happens when a constituent provides an interface and other constituents use it, and besides when a constituent submits an event and other constituents receive it.
2.4 Characteristics and Properties of a Software Component
A package constituent conforms to a theoretical account. The theoretical account supports the independent deployment of constituents, and encapsulates a unit of informations and logic. The theoretical account helps specify the interface decently, and it ensures the constituents are well-packaged and are deployable [ 66 ] .
There are some features of constituent development. They are as follows [ 60 ] :
1. Standardized – with current engineering, execution of constituents should follow a standard constituent theoretical account. The theoretical account defines specific constituent interfaces, metadata, certification, composing and deployment.
2. Independent – it should be possible to incorporate and deploy constituents without interfering with other constituents.
3. Composable – composing of constituents is possible through chiseled interfaces.
4. Deployable – a constituent is binary and does non necessitate to be compiled before it deployed. It must be able to run as an entity above a constituent platform.
5. Documented – constituents must hold a chiseled description of their functionality so that constituent users can take the appropriate 1.
Some belongingss of a constituent are [ 60 ] :
1. Heterogeneity.
Assorted types of constituents exist within different webs, above operating systems, and written utilizing programming linguistic communications.
2. Interoperability.
The chief thought of constituents is interoperability among different constituents. However current constituents are developed with different theoretical accounts ( EJB, CORBA, or.NET ) , and each theoretical accounts have their ain features. Therefore an EJB constituent can non pass on easy through a.NET constituent. However some researches such as Vienna Project [ 41 ] , have been done to join forces these theoretical accounts.
3. Configurability.
Components should be easy to configure, supplying flexibleness for the constituent user.
4. Composability.
Components are integrated to do complete applications. To enable composability, constituents should hold clear interfaces.
5. Packaging and deployment.
Components are distributed in bundles. Component users install the bundle utilizing information contained in the bundle.
2.5 Component Interfaces
The UML 2.0 criterion describes an interface as “ a aggregation of operations that are used to stipulate a service of a category or a constituent ” [ 10 ] . An interface is a named collected set of operations, each of which has a defined signature and perchance a return type [ 66 ] . The signature consists of the figure, type and go throughing manners of statements, and hence it has to be alone so clients are able to raise the right interface.
A constituent may supply interfaces to other constituents or objects, and it besides may necessitate interfaces from different constituents. The Object Management Group ‘s CORBA uses a particular naming for these interfaces [ 43 ] . The term ‘Facet ‘ is used to place provided interfaces, and ‘Receptacles ‘ to place needed interfaces. Figure 2 & A ; # x2011 ; 1 shows a constituent and its provided-required interfaces. A constituent may declare many provided interfaces as services to other constituents, and it besides may hold required interfaces from other constituents.
The constituent users or the clients do non necessitate to cognize the internal construction of the constituent, and constituent developers do non necessitate to understand the client ‘s demands. The constituent developers follow a particular contract for an interface to implement a constituent, and the constituent clients use this contract definition to accomplish their ends. This contract specifies how each party should pass on, therefore it must be chiseled. The contract states that the Godhead should implement services consequently. It besides directs what the users should make to utilize the interfaces. The contract should depict the pre-condition for naming an interface and the post-condition after finish usage of an interface. Before utilizing a constituent, the constituent user is responsible for guaranting the pre-conditions are met, and the Godhead makes certain that the post-conditions are satisfied [ 60 ] . Table 2 & A ; # x2011 ; 1 shows the differences between interface specifications and component specifications.
Table 1 & A ; # x2011 ; 1 The difference between Interface Specification and Component Specification [ 60 ] .
|
Interface Specifications |
Component Specifications |
|
* A list of operations * Defines logical information theoretical account * Represents a contract with the client * Specifies how operations affect or rely on the information theoretical account * Describe local consequence merely |
* A list of supported interfaces * Defines the relationships between the information theoretical accounts of different interfaces * Represents a contract with the implementer * Defines the execution and runtime unit * Specifies how operations must be implemented in footings of use of other interfaces |
The CORBA Component Model ( CCM ) defines events as a manner for a constituent to interact with other constituents. The events are generated from an event beginning and captured in an event sink. Change of province may trip events and there may be captured by other constituent. Events may besides include signals, calls or passing of clip and can be synchronal or asynchronous [ 10 ] .
Interaction between constituents through interfaces demonstrate two types of interactions: an incoming interaction and an outgoing interaction [ 66 ] . Interactions happen through interfaces, or through events produced or being received. If a constituent ‘X ‘ entrees an interface that is provided by another constituent ‘Y ‘ , so ‘Y ‘ will hold an incoming interaction from ‘X ‘ . If a constituent ‘X ‘ publishes an event which is consumed by constituent ‘Y ‘ , so ‘X ‘ is said to raise an outgoing interaction to ‘Y ‘
Using the old illustration, the Stock Distributor monitors a stock database. If there are alterations in the database value, this constituent generates an event via an event beginning ( Notifier-out ) to a corresponding event sink ( Notifier-in ) . Several Stock Broker ( SB ) constituents can react with their event sinks. When one or more Stock Broker constituent ( s ) are interested in the new value, it/they can raise a petition operation through their receptacle ( Get-Quoter-Info ) . Component Stock Distributor has an incoming interface Quoter-Info method and a Notifier-out event beginning. Component Stock Broker has an outgoing interface Display-Info method and an incoming interface Get-Quoter-Info and Notifier-In event.
2.6 Component Integration or Composition
Harmonizing to definitions defined antecedently, an application can be built by uniting different functionalities from assorted constituents. The definitions permit, for illustration, piecing of several 100s of constituents to do a complete package application. For obvious grounds a criterion is needed to do the constituents work together. Figure 2 & A ; # x2011 ; 4 illustrates how constituents can be integrated to build a complete application.
The criterion provides the gum that binds the constituents with the application. There are three degrees of adhering [ 12 ] :
* High degree adhering – a coordination system describes how constituents provide a needed functionality, and how the receiving systems use their functionality ;
* Lower degree adhering – there should be common services to transport out common undertakings ; and
* Lowest degree adhering – the theoretical account should implement the needed coordination.
Many criterions are available, nevertheless systems designed harmonizing to these criterions still do non incorporate good [ 40 ] , chiefly because of:
1. The demand to purely conform to the given criterion, which frequently may non be comprehensive [ 4, 6, 8, 15 ] ;
2. Differences in behavioural features of constituents themselves [ 12, 55 ] .
A more recent work to turn to these jobs is proposed by Oberleitner et. Al. [ 41 ] , who have developed the Vienna Component Framework to enable composing across different constituent criterions.
Integration of many constituents into a big application raises the issue of package quality. The constituents may be built by different companies, with each holding different qualities. Another job is re-assembling a company ‘s bequest codification to follow with a new constituent based criterion. These jobs create several types of hazards, which have to be identified by a developer [ 41, 66 ] . To undertake these hazards, it is utile for the developer to obtain more information from their package artefacts. A set of prosodies would be utile in garnering such information. These prosodies help in measuring the hazards, place the critical values, and supply an penetration to the construction of the bequest system.
2.7 Component Models
A component theoretical account defines how to construct a individual constituent, and how to enable interaction between constituents or with other parts of package application [ 66 ] . A particular mechanism is needed for component creative activity, input/output informations exchange, and pull offing component interactions [ 66 ] . Some theoretical accounts may specify extra characteristic such as standard formats for cryptography, certification or obligatory producer-independent interfaces. A component theoretical account is normally implemented on top of an operating system. It manages an inter-component communicating, and a component-operating system communicating [ 66 ] . An operating system might include a component theoretical account as portion of its execution, nevertheless it might restrict the capableness of the constituent theoretical account [ 25 ] . Figure 2 & A ; # x2011 ; 5 show how a component theoretical account helps communicating between constituents A, B and C, and besides how they communicate with the operating system.
Component theoretical accounts define criterions for interface, calling, metadata, component behaviour specification, component execution, interoperability, customization, composing and deployment [ 25 ] . Table 2 & A ; # x2011 ; 2 shows sum-ups of the constituent theoretical account elements.
Table 1 & A ; # x2011 ; 2 Component Model Elements [ 25 ]
|
Standards |
Descriptions |
|---|---|
|
Interfaces |
Specifies the constituent belongingss and behaviour. Interfaces define contracts between constituents and their clients. |
|
Naming |
Specifies alone names for constituents and their interfaces to avoid name clang. |
|
Meta informations |
Defines information about constituents, interfaces and their relationships. |
|
Interoperability |
Defines criterions for communicating between constituents implemented utilizing different linguistic communications or platforms. The communicating may go on in the same computing machine or over a web. Some specifications for interoperability are Simple Object Access Protocol ( SOAP ) , Microsoft ‘s.NET platform, Java ‘s Remote Method Invocation ( RMI ) and CORBA ‘s Internet Inter-Orb Protocol ( IIOP ) [ 66 ] . |
|
Customization |
Allows constituent to be adapted to a specific demand. |
|
Integration |
Needs a set of regulations to enable component integrating, and omission from the system construction. |
|
Development support |
Requires a set of regulations to back up component replacing by new versions. |
|
Packaging and Deployment |
Provides a set of regulations to back up bundling and constellation of the constituents in the system. |
Some major establishments have defined criterions for edifice constituents. Microsoft proposes COM, OLE/ActiveX, COM+ and.NET CLR [ 33, 34 ] . The ObjectManagement Group ( OMG ) released CORBA, CCM, OMA and MDA as its criterions for their constituent theoretical account [ 44 ] . Sun Microsystems offers Java 2 Enterprise Edition ( J2EE ) , JavaBeans and EJB as a constituent theoretical account criterion [ 63 ] .
2.7.1 Microsoft ‘s COM and.NET
Component Object Model ( COM ) was proposed by Microsoft in 1995 for component-based support [ 1 ] . This first Microsoft theoretical account supports component integrating, packaging and criterions for interoperability between assorted constituents. Distributed COM ( DCOM ) is an extension of COM, back uping the ability to incorporate constituents in a distributed system. COM+ [ 1 ] , another extension of COM, provides an endeavor solution. COM+ besides includes characteristics such as Microsoft Transaction Service ( MTS ) , Microsoft Message Queue ( MSMQ ) , Microsoft Active Data Objects ( ADO ) , and Microsoft Cluster Server [ 20, 33, 36, 66 ] .
The Microsoft.NET model [ 34 ] is the new architecture from Microsoft to back up the building of component-based system. It simplifies the development of a constituent compared to the COM/DCOMtechnology. At the clip of authorship, the current version is.NET model 3.0. This architecture is integrated into Microsoft OS platforms. The model offers category libraries to cover a larger functionality than COM/COM+ , particularly in interoperability characteristics. The.NET model support different scheduling linguistic communications ( C++ , C # , J # , Visual Basic ) . XML is used as a agency for communicating between constituents [ 20, 34, 36, 66 ] .
The foundation of the.NET architecture is a Common Language Runtime ( CLR ) [ 34 ] , which acts like the Java Virtual Machine ( JVM ) in Java. Each constituent in.NET model is integrated in an assembly bundle which is coded in Microsoft Intermediate Language ( MS IL ) . The MS IL codification is translated in CLR into native codification by a Just In Time IL compiler at runtime.
The.NET Framework is available in.NET model SDK and is a footing of Microsoft Visual Studio. The.NET Framework sits on top of Common Language Runtime ( CLR ) . Web services replace DCOM engineering by using XML, SOAP and HTTP protocols. To construct a web application, .NET model support a set of category libraries including ASP.NET web signifiers. Windows Forms are provided to construct a desktop application. ADO.NET is used for informations entree. .NET IDE SDK supports all.NET linguistic communications such as C # , C++ , J # , VB.NET. Figure 2 & A ; # x2011 ; 6 illustrates elements of a.NET model. This construction is to the full described in [ 34 ] .
2.7.2 OMG ‘s CORBA
The Object Management Group ( OMG ) defines the CORBA Component Model ( CCM ) [ 44 ] . CCM is the new theoretical account based on the Common Object Request Broker Architecture ( CORBA ) [ 42 ] to supply a common model for component integrating. An Object Request Broker ( ORB ) , the bosom of CORBA, provides the transparence mechanism to enable communicating in different locations, linguistic communications, and platforms. The ORB hides low-level inside informations for each platform-specific networking interface. The developer does non necessitate to be concerned with the execution inside informations of specific substructures, so is able to concentrate more on patterning at the concern solution degree. CORBA provides advanced services such as continuity and dealing support [ 20, 36, 43, 66, 69 ] . CORBA is supported by Unified Modeling Language ( UML ) [ 66 ] . UML is supported by the Meta-Object Facility, XML Metadata Interchange ( XMI ) , and the Common Warehouse Metamodel ( CWM ) [ 44 ] . Figure 2 & A ; # x2011 ; 7 shows an architecture position of CORBA and OMG IDL.
2.7.3 Sun ‘s EJB
Sun Microsystems ‘ Enterprise Java Bean ( EJB ) is a component theoretical account for server-side component-based systems for Java platform Enterprise Edition ( Java EE ) [ 63 ] . The Bean is the basic reclaimable constituent in EJB. Beans are classified into session beans and entity beans [ 63 ] ; Session beans provide support for concern procedure abstraction, and entity beans provide support for informations storage. The communicating between the beans is managed in an EJB container or waiter. The container provides bean life direction services, name services, continuity, dealing support security, burden reconciliation and other services [ 20, 36, 63, 66 ] . Figure 2 & A ; # x2011 ; 8 shows an architectural position of an EJB beans.
2.7.4 Comparisons between.NET/COM+ , CORBA and EJB
The above three attacks portion some common features, such as unvarying informations transportation, event connexions, meta information, some signifier of continuity, serialisation or externalisation [ 66 ] . However there are besides differences in the execution of the criterions.
The EJB and CORBA constituent theoretical accounts support execution on different runing systems and hardware, nevertheless Microsoft ‘s.NET/COM+ runs merely in the Microsoft OS environment. This represents an advantage for Microsoft because it provides more flexibleness to better on public presentation and interoperability [ 20 ] . EJB and CORBA both need a particular model to let interoperability and communicating between constituents and the implicit in platform with attach toing debasement of public presentation.
All the criterions have similar interface theoretical accounts ; nevertheless they differ in the definition linguistic communication of the interface. CCM uses CIDL ( Component Implementation Definition Language ) to specify the place of its constituent and OMG ‘s IDL to specify the interfaces [ 42 ] There is no IDL for.NET ‘s CLR and Java ‘s EJB as the information is stored as metadata [ 66 ] . The staying basic features of the three theoretical accounts are compared in Table 1 & A ; # x2011 ; 3.
Table 1 & A ; # x2011 ; 3 Comparisons of.NET/COM+ , CORBA, EJB [ 20, 36, 66 ]
|
Properties |
.NET/COM+ |
CORBA |
EJB |
|---|---|---|---|
|
Basic Component |
.NET/ COM constituent |
Eyeball |
Bean |
|
Component composing |
Multiple categories utilizing specific linguistic communication |
Multiple categories from any execution |
Multiple categories from Java execution |
|
Component theoretical account for web waiter |
ASP.NET |
None |
JSP/Servlets |
|
Component transportation format |
CLI Assembly ; COM cab files |
None |
Java JAR files |
|
Connection |
“ Via an interface arrow ” |
Via IDL |
“ via event and hearer ” |
|
Cost |
Expensive |
Low |
Low |
|
Distributed Mechanism |
.NET Framework / DCOM, cyberspace |
CORBA IIOP utilizing an Eyeball |
Java RMI ( Remote Method Invocation ) |
|
Enterprise Solution |
.NET endeavor waiter |
CORBA services |
Java EE |
|
Home Interface |
.NET place |
Homes are CORBA object. |
EJB Home object created by EJB container |
|
Interface |
OLE IDL, MIDL |
OMG IDL |
Using Java linguistic communication |
|
Interoperability |
Yes |
Yes |
Yes |
|
Messaging Model |
MSMQ |
CORBA IIOP |
JMS |
|
Naming and Directory Servicess |
.NET namespace, active directory |
CORBA naming |
Java EE built-in portion, Open specification |
|
Performance |
Very good |
Good |
Good |
|
Continuity |
ADO.NET/OLE-DB |
CORBA constituent bundle |
Entity bean |
|
Platform |
Windows |
Windows, Unix ( multiple platform ) |
Windows, Unix ( multiple platform ) |
|
Portability |
Windows platform |
Good |
Good |
|
Programing Language |
Many linguistic communications ( C # , C++ , J # , VB ) |
Many linguistic communications ( Java, C++ ) |
Java |
|
Scalability and Load Balancing |
Service for scalability |
Different degree of constituent life-time direction |
Provides pooling for database connexions |
|
Security |
SSL+SSPI |
CORBA particular |
SSL, JAAS |
|
Security |
.NET security |
CORBA Security |
Security Manager |
|
State Management |
Stateless |
Method, dealing, petition, session and planetary province direction |
Stateful and homeless bean |
|
Support Tool |
Very good |
Good |
Good |
|
Transaction Support |
MTS, MSDTC |
CORBA dealing support |
JTS, JTA |
2.8 Decisions
Component-based package development originally built upon the object-oriented paradigm, nevertheless its definition allows for the non object-oriented package to go a constituent. Components are so integrated with other constituents to construct complete applications. Interfaces are used to back up communicating between different constituents. Components may supply interfaces to other constituents and may necessitate interfaces from other constituents.
There is a demand for criterions for a component execution. Such criterions allow constituents to pass on with other constituents and with the operating platform or operating system. Some well-known criterions are Microsoft.NET/COM+ , OMG ‘s CORBA Component Model and Sun ‘s EJB. Each criterion has different attacks in the execution ; nevertheless they besides portion the same features.
