Web services is a Service Oriented Architecture implementation.
But, can we say that CORBA, RMI and the Java EE platform are also an implementation of SOA?
If you say that SOA means WS-* standards, then the answer is "no".
But if SOA means distributed components communicating using an agreed-upon protocol, then the answer is yes, you can think of CORBA, RMI, and Java EE as SOA. (My advice is to drop the "2" - it's been out of the picture for a long time. Please refer to it as Java EE unless you want to appear out-of-date.)
Even web services have at least two flavors: SOAP and REST. You might also include XML-RCP.
The difference in all cases is the choice of protocol.
SOAP uses its own XML request/response idiom over HTTP.
REST is straight HTTP - GET, POST, URL for every request.
CORBA uses an OMG standard protocol. Interoperability between ORBs, and different bindings for each language, used to be a big problem. It's been so long since I've used CORBA that I have no idea of the current state of the art. I don't know anyone who uses CORBA anymore. From my vantage point, it's a failed, dead technology.
RMI is the Java-only answer to CORBA. All endpoints must be implemented in Java and speak RMI.
Java EE uses RMI as the underpinnings of EJBs.
Simple and open win: that's why HTTP-based protocols are growing in popularity.
yes. WS-* is one of the mostly used ways in which SOA is implemented.
Related
Hi went through Enterprise Integration Patterns by Gregor Hohpe and Bobby Woolf.
http://www.eaipatterns.com/toc.html
I also went through Camel and Mule's compliance with these integration patterns -
http://www.mulesoft.org/documentation/display/current/Understanding+Enterprise+Integration+Patterns+Using+Mule
http://camel.apache.org/enterprise-integration-patterns.html
I see that both Mule and Camel allow applications to be deployed and accessed via webservices like SOAP or REST, SOAP being more RPC style. They allow massive integration support using opensource utilities like CXF and Jersey. In fact Mule also supports RMI endpoints - which will give remote method invokation capability as well which is a well-accepted form of Integration.
I understands ESBs are built around a Message Bus with additional support for other protocols however ESBs only comply to EIP and EIP is not just ESBs.
Question is why SOAP/REST or their transport protocol not considered as "Integration Styles" and which is Enterprise Integration so "Message Oriented"?
I am a novice compared to the great minds which designed these patterns but trying to understand the lopsided message-y nature of Integration patterns. I admit it isn't quite the QnA format of stack overflow but will request Mods to keep it alive for a while so that people can share their opinions.
As for SOAP, it would put it under the Integration Style "Remote Procedure Invocation", since it's pretty much what SOAP implements in reality (I won't consider the SOAP over JMS hybrids here with a potential to mix RPC with Messaging..).
REST is, interface wise, very different from SOAP in that it's resource driven instead of service driven. I would non the less group it under the "RPC" style since it's just another format of syncrhonous RPC calls.
I would, however, not put too much effort in theory of what EIP integration style a specific message pattern implements.
Look at a specific scenario at hands instead and use the EIP to model your specific integration.
I've seen integrations of file transfers that in realtiy implemented RPC patterns or SOAP services that in reality implemented messaging (although I don't really recommend do this).
A concrete example: consider the usage of a dedicated file upload service, which happends to be built using SOAP technolgy, which uploads a CSV file to a file area on a server, from where it's picked up by some other system. I would call this file based integration on a high level.
Another example is that Messaging systems sometimes are implemented using a shared database. Still the integration style using them is messaging, not "Shared Database".
Think about how your integration should work on a high level, then apply the various protocols to do the grunt work.
Lots of websites (e.g. twitter, stackexchange) provide RESTful OPEN APIs based on the HTTP protocol. Can I design a RESTful service based on some other protocol (such as raw TCP)?
The short answer is that a RESTful service does generally imply HTTP, but it's not strictly necessary. The wikipedia entry includes a section on implementations outside the web, though it's pretty brief and really only talks about Common Management Information Protocol (CMIP).
Realistically, to most developers, RESTful services operate over HTTP.
You could surely take inspiration from RESTful protocols on the web and build your own similar protocol over raw TCP, but you may well finding yourself implementing it in the language of HTTP. At that point you may want to ask yourself why you didn't just use HTTP in the first place.
If you look at Roy Fielding's PhD thesis, you'll see that REST is defined in chapter 5, while it's applied to HTTP in chapter 6.
"Representational state transfer" is indeed quite abstract. There's no reason you couldn't apply it to your own adhoc protocol. The aim is to make it stateless, to have safe read methods (that are cacheable), and if possible idempotent write methods.
If you adhere to the true tenants of the architecture where every operation is ignorant of historical operations you could probably drum up something a bit different. Currently the easy Put, get, post and delete operations lend well to http based service calls.
they have many common features. but how the difference?
MOM allow asynchronous while SOA does not, this is the only difference?
SOA, Service Oriented Architecture, is an architecture that defines how to structure access to business information between different applications. In a nutshell, usually, one application needs something done with a piece of information (may it be an orderfile or anything else) that application has a need. Another application may be able to do the corresponding processing of that piece of information, hence it has a capability. The first application then Consumes the Service of the second application, which Provides the Service (no matter the underlying technology, which can be anything such as JMS, HTTP/SOAP, HTTP/REST, EMail, FTP, etc.). To make this work, a Contract between the first application and the Service has to be defined which clears such things out as Message Format (XSD or similar), Protocol (HTTP/SOAP? JMS?) etc.
MOM, Message Oriented Middleware, on the other hand is just a family of software/middleware platforms. They are actual implementations, and not a high-level concept like SOA. They can be used to implement a SOA architecture, an Event Driven architecture or other architectures. Usually, MOM enriches a set of applications with asynchronous messaging where a MOM server stores and forwards the messages. Often things such as transactions, guranteed delivery, fail-over, loose coupling and load balancing are built into MOM implementations. Examples of MOM are IBM WebSphere MQ, Apache ActiveMQ, RabbitMQ, JBoss HornetQ, etc.
Message oriented middleware (MOM) is a type of technology where as SOA is a type of architecture. Even though a lot of people think about web-service when they talk about SOA, you can use MOM to implement it as well (in fact in many cases that's the better option)
I have been looking a lot at SOA recently. Isn't CORBA exactly the same thing as SOA?
In addition to the fact already mentioned, that SOA is an architecture, and CORBA a specific implementation.
CORBA doesn't implement SOA
the main difference is that CORBA is Object Oriented or Component Oriented and SOA is Service Oriented
The main technical difference (in my opinion) is that in SOA you pass messages (or data objects) and in CORBA you can pass generic objects (which can have methods)
so although you can implement SOA using CORBA (by limiting you self to a subset of the functionality), the standard way of using CORBA isn't service oriented.
The difference between CORBA and SOA is that CORBA is a specific technology, whereas SOA is a style of architecture.
SOA as a concept has been around for years, but was only more recently named as such. There are many technologies that can be said to implement SOA - either completely, or aspects of it. CORBA could be said to be one of them, although the term wasn't around when CORBA was created.
CORBA certainly implements are large part of the SOA surface area, but I don't think you could say it does so completely (whatever that means). SOA can be a bit vague.
While there is no "official" definition of SOA, part of the point of it is to decouple the various services from each other. This includes possibly decoupling the implementation (platform and technology) used in the service. As an example if one exposes a service via WebServices, any client be it java/python/.Net etc... could consume this service - but utilizing a RPC/remote procedure call framework will often tie you into a particular platform/implementation in order to call the service.
Corba does offer some of what SOA promises, but is at best a subset of what SOA is "meant to be"
The main difference though is that SOA is a general architectural concept, while Corba is a technology implementation of the RPC/Remoting concept
Not really. SOA is an architectural style while CORBA is a particular technology with which you can implement SOA.
CORBA and SOA are both architectures. It is wrong to say CORBA it is an implementation. It is not. It is an architecture, a vision of systems build with objects. SOA is also an architecture, a vision of systems build with services. They both are ways to organize your systems as a collection of either objects or services. There are specific implementations for CORBA as well as for SOA.
They are both technologies. They both give you receipts and recommendations for structuring your systems and for managing complexity. There are tools developed by third parties to support these technologies for both of them.
The objects in a Common ORB Architecture (CORBA) provide services so you can think of a translation between Service Oriented Architecture (SOA) and Common ORB Architecture. They are not the same thing, but one can imagine implementing a software system with either the one or the other, making them, from a certain point of view, equivalent.
They are not the same thing in the same way as Object Oriented Programming and Structured Programming or Functional Programming are not the same thing, although one could use any of the above mentioned programming styles to implement a certain functionality.
They are inherently different because one depends on the technology (CORBA) and the other doesn't.
CORBA is an open standard developed by the OMG (Object Management Group) for the use ORB (object request broker) middleware with a great focus on interoperability (software platforms, hardware platforms and programming languages).
SOA is a style of software design where services are provided to the other components by application components, through a communication protocol over a network. The basic principles of service-oriented architecture are independent of vendors, products and technologies.
I had the same doubt as you because the definition of SOA is too broad and I can see many concepts of CORBA can be mapped naturaly to SOA's terminology. For example in CORBA, clients (objects) ask to servers (also objects) to do some work through a communication protocol over a network. Moreover CORBA implementations provide general services like logging and event support. I think this link summarizes the relation between CORBA and SOA:
The first service-oriented architecture for many people in the past was with the use of Object Request Brokers (ORBs) based on the CORBA specification. The CORBA specification is responsible for really increasing the awareness of service-oriented architectures.
NServiceBus and MassTransit are two tools that can be used to implement messaging with MSMQ and other message queues.
I find that once you start using messaging to have applications talk to each other, you don't really want to go back to the old RPC style.
My question is, what other tools are out there? What tools do you use?
Apache ActiveMQ is probably the most popular and powerful open source message broker out there with the most active open source community behind it as well as commercial support, training and tooling if you need it.
One of the more interesting aspects of ActiveMQ is its wide support for a large number of different language bindings and transport protocols
WebSphere Message Broker is IBM's flagship ESB which runs ontop of MQ.
They also produce WebSphere ESB which is a slightly lighter offering which specialises in ESB across web services.
We use WCF services for synchronous message based operations, and nServiceBus for anything asynchronous.
Rogue Wave is very popular [ http://roguewave.com/products/hydra/ ]
So are IBM's Websphere offerings [ http://en.wikipedia.org/wiki/Mqseries ]
WCF is extremely powerful and should be looked into by anyone in the .NET space starting up a message based system.
I would recommend against BizTalk unless you can make a lot of use out of it's adapters (ie. you have a lot of old systems to communicate with).
Nuedesic makes a great WCF based ESB, Neuron, if you are willing to pay a bit.
I use IBM software stack because it has the widest set of features (pub/sub, async, sync) and platform support (60+ combination of platform, languages) and also a great set of free tools provided by IBM
For Operations, I use use the linear log rotation IBM WebSphere MQ supportpac
For development and testing, I like RFHUTIL to generate fake cobol, java, MS objects, other binary and text objects and SOAPUI to invoke HTTP web services. If I need to invoke MQ based web services, I go back to RFHUtil. Of course Websphere MQ Explorer for admin.
We use the old WebSphere Message Broker 6.1 (now IBM Integration Bus) that is fast and reliable once you are acquainted.