- The Common Object Request Broker Architecture.
- It's middleware!
- An open standard for distributed object computing.
- Language neutral.
- Location transparent (mostly).
- Administered by the Object Management Group (OMG).
- A nonprofit consortium founded in 1989.
- Over 800 organizations.
- Develops and issues CORBA specifications.
- No software or implementation details.
- Supports various special interest groups.
- At the highest level, the OMG specifies the Object Management
Architecture (OMA).
- The OMA comprises four components, two system oriented and two
application oriented:
- The Object Request Brokers and Object Services are the system-oriented
components.
- The Application Objects and Common Facilities are the
application-oriented components.
- The Object Request Brokers provide location-independent communication.
- Objects Services provide object management - creating, accessing,
relocating, and so on.
- The Common Facilities are generic application functions - printing,
databases, and the like.
- The Application Objects work the system components in behalf of
applications.
- The OMG is really into objects.
- The object model specifies external, implementation-independent
semantics.
- Objects model things.
- Objects support operations on the objects, defining object behavior.
- An object type describes an object.
- Object types can be related by subtyping.
- CORBA implementations must implement the object model.
- The Interface Definition Language (IDL).
- IDL language mappings to c, c++, Java, and so on.
- Invocation and dispatching support; stubs and skeletons.
- Invocation can be static (compile-time bound) or dynamic (run-time
bound).
- There are static and dynamic stubs and skeletons.
- Object adapters.
- The Object Request Broker (ORB) provides concurrency and communication.
- Common Object Services such as naming and event notification.
- Inter-ORB Protocols.
- The complexity of
- developing distributed computations.
- The distributed-object model of computation.
- using distributed computations.
- Just call this little method here.
- inter-language development.
- The language-agnostic IDL.
- The Common Object Services (COS)
- Domain interfaces.
- Application interfaces.
- An object is a server handling requests.
- A target object is a particular object.
- A client makes requests of objects.
- A server is one or more objects.
- A request is a message from client to target object.
- A servant implements an object.
- A domain is a segregated collection of objects.
- A client calls through the stub.
- The local ORB sends the request to the remote ORB.
- The remote ORB dispatches the request to the object adapter.
- The object adapter finds and dispatches to the servant.
- The servant handles the request and returns the reply.
- Synchronous; typical rpc (send, wait for reply).
- Deferred synchronous using polling.
- Request, no response (one-way).
- Asynchronous through polling or callbacks.
- For C, C++, Java, and lots more.
- Each mapping exploits features of the host language.
- CORBA requires that mappings be transparent.
- Mappings should blend in with both the language and CORBA.
- Initially the Basic Object Adapter (BOA).
- Now the Portable Object Adapter (POA).
- Others possible too.
- CORBA initially left inter-orb communication undefined.
- That didn't work too well (surprise!).
- The General Inter-ORB Protocol (GIOP) specifies a standard transfer
syntax over a minimal transport protocol.
- The Internet Inter-ORB Protocol (IIOP) implements GIOP over TCP/IP.
- Much like an IDL is mapped to a language.
- Other protocols are possible too.
This page last modified on 29 March 2004.