Nothing Special   »   [go: up one dir, main page]

Corba

Download as docx, pdf, or txt
Download as docx, pdf, or txt
You are on page 1of 2

Topic : CORBA(Common Object Request Broker Architecture)

NAME: shubham D Gawali.


Abstract:
Distributed objects are the next wave in Internet innovation. CORBA, the Common
Object Request Broker Architecture defined by the Object Management Group (OMG),
specifies how software objects distributed over a network can work together without regard
to client and server operating systems and programming languages.
CORBA is a complete distributed object platform. It extends applications across networks,
languages, component boundaries, and operating systems. A CORBA Object Request Broker
(ORB) connects a client application with the objects it wishes to use.
The client application does not need to know whether the object resides on the same
computer or on a remote computer elsewhere on the network. The client application needs to
know only two pieces of information: the object's name and how to use the object's interface.
The ORB takes care of the details of locating the object, routing the request, and returning the
result.
CORBA grew at the same time as three influential trends, which lent credence to the CORBA
vision. First, the software development community realized the importance of object-oriented
programming techniques, even though they’d been around for the better part of two decades.
Second, industry leaders - including IBM, Microsoft, and Apple - were advocating new
application models based on small, task-specific components instead of large, general-
purpose monoliths. The components would be easy to write and update, since they were
small.
Developers could more conveniently, and cheaply, upgrade only those parts of their software
that were out of date, and users wouldn't have to purchase entirely new versions of the entire
package. And the small components could be distributed over a network more easily than
their gargantuan ancestors. The more enlightened of these component architectures promised
a cross-platform future, where all components could work together entirely independent of
the underlying operating system.

Introduction:
The Common Object Request Broker Architecture (CORBA) is an emerging
open distributed object computing infrastructure being standardized by the Object
Management Group (OMG). CORBA automates many common network programming tasks
such as object registration, location, and activation; request demultiplexing; framing and
error-handling; parameter marshalling and demarshalling; and operation dispatching. The
following figure illustrates the primary components in the OMG Reference Model
architecture.
• Object Services -- These are domain-independent interfaces that are used by many
distributed object programs. For example, a service providing for the discovery of other
available services is almost always necessary regardless of the application domain. Two
examples of Object Services that fulfill this role are:
o The Naming Service -- which allows clients to find objects based on names;
o The Trading Service -- which allows clients to find objects based on their properties.
• Common Facilities -- Like Object Service interfaces, these interfaces are also horizontally-
oriented, but unlike Object Services they are oriented towards end-user applications. An
example of such a facility is the Distributed Document Component Facility (DDCF), a
compound document Common Facility based on OpenDoc. DDCF allows for the presentation
and interchange of objects based on a document model, for example, facilitating the linking
of a spreadsheet object into a report document.
• Domain Interfaces -- These interfaces fill roles similar to Object Services and Common
Facilities but are oriented towards specific application domains. For example, one of the first
OMG RFPs issued for Domain Interfaces is for Product Data Management (PDM) Enablers
for the manufacturing domain. Other OMG RFPs will soon be issued in the
telecommunications, medical, and financial domains.
• Application Interfaces - These are interfaces developed specifically for a given application.
Because they are application-specific, and because the OMG does not develop applications
(only specifications), these interfaces are not standardized. However, if over time it appears
that certain broadly useful services emerge out of a particular application domain, they might
become candidates for future OMG standardization

How CORBA Works:


A CORBA Object Request Broker (ORB) is the middleware that
establishes the client-server relationship between objects. Using an ORB, a client object can
invoke a method on a server object that can be on the same machine or across a network. The
ORB intercepts the call and finds an object that can implement the request, pass it the
parameters, invoke its method, and return the results. CORBA, like SQL, provides both static
and dynamic interfaces to its services. The client does not have to know the object's location,
its programming language, its operating system, or any other system aspects that are not part
of an object's interface. Also, the client and server roles are dynamic: an object on the ORB
can act as either client or server, depending on the occasion.
Together, ORBs and the CORBA architecture provide the mechanism for CORBA objects to
communicate. The objects are small software components that provide some kind of a
service, such as access to a database, account management, or inventory tracking.
Fundamental to the architecture are the ORBs. For any client or server to be a part of the
CORBA scheme, it must include an ORB to help it find and communicate with other
CORBA objects. Once outfitted with an ORB, a client or server can use the services of any
CORBA object on any server or host on the network.
An object can be both a client and a server: when it provides services to another object, it's a
server; when it requests services from another object, it's a client. The CORBA architecture
provides a set of services that help objects interact with each other. (In the CORBA world,
services means both the services provided by the CORBA architecture to help objects
communicate and the functionality provided by the objects themselves.)

You might also like