Service Oriented Architecture (SOA) Concepts

Business Process Execution Language (BPEL)

2015-02-03T05:27:00.002-08:00

BPEL (Business Process Execution Language) is an XML-based language that allows Web services in a service-oriented architecture (SOA) to interconnect and share data.

Programmers use BPEL to define how a business process that involves web services will be executed. BPEL messages are typically used to invoke remote services, orchestrate process execution and manage events and exceptions.
BPEL is often associated with Business Process Management Notation (BPMN), a standard for representing business processes graphically. In many organizations, analysts use BPMN to visualize business processes and developers transform the visualizations to BPEL for execution.
BPEL was standardized by OASIS in 2004 after collaborative efforts to create the language by Microsoft, IBM and other companies.

Why do we need BPEL?
So, why was the new language created? Why do we even need BPEL? BPEL provides:

Support for web services relationships and interactions that are engaged in both short- and long-term business transactions. BPEL provides the foundation for automating business processes.
Message exchange correlation for long running message exchanges, not just over a minute or two, but over days, weeks or months. BPEL provides industry-standard support for processes that require very long time periods to complete.
Implementation for the parallel processing of activities, which permits the execution of non-dependent actions concurrently to improve process performance.
For the mapping of data between partner interactions, so it is possible, for example, to take the result from one web service and use it to invoke another web service.
The BPEL standard provides consistent exception and recovery handling for deployed business processes.

What are the Benefits of BPEL?
Some of the benefits of using BPEL include:

BPEL is SOA (Service Oriented Architecture) compliant, meaning that it is based on web services, which are the set of protocols by which such services can be published, discovered and used in a technology neutral, standard form.
BPEL allows us to leverage existing standards and skill sets, all in a common language.
BPEL deployed orchestrations are web services themselves, and therefore fit naturally into the existing Web Services stack.
BPEL is expressed entirely in XML, uses and extends the WSDL 1.1 definitions and uses XML Schema 1.0 for the data model.
BPEL is platform and vendor agnostic, and so a BPEL process will run on any engine that is BPEL-compliant.
BPEL processes are interoperable between and among existing/running web services because they are themselves web services.

Examples of BPEL Process

Example 1 :The Hello World BPEL Process
	The following actions take place: The Hello World BPEL process accepts the input from the WSDL client partner link by using a receive activity. The receive activity repackages the input into a variable. The Hello World BPEL process adds the greeting using an assign activity, and then sends the result back to the client application through the partner link as output by using the reply activity.

Example 2 :Example BPEL process for travel arrangements:

Extensible Markup Language (XML)

2015-02-03T05:25:00.001-08:00

There are countless file extensions out there and new ones seem to crop up every day. When you happen to discover one you have never heard of before, I bet your initial instinct is to suspect malware, rather than being excited to find out what it is. Did you ever wonder what an XML file is?

XML stands for Extensible Markup Language. A markup language is used to annotate text or add additional information. These annotations are not shown to the end-user, but are needed by the ‘machine’ to read and subsequently process the text correctly.

The essence of XML is in its name: Extensible Markup Language.

Extensible	:	XML is extensible. It lets you define your own tags, the order in which they occur, and how they should be processed or displayed. Another way to think about extensibility is to consider that XML allows all of us to extend our notion of what a document is: it can be a file that lives on a file server, or it can be a transient piece of data that flows between two computer systems (as in the case of Web Services).
Markup	:	The most recognizable feature of XML is its tags, or elements (to be more accurate). In fact, the elements you’ll create in XML will be very similar to the elements you’ve already been creating in your HTML documents. However, XML allows you to define your own set of tags.
Language	:	XML is a language that’s very similar to HTML. It’s much more flexible than HTML because it allows you to create your own custom tags. However, it’s important to realize that XML is not just a language. XML is a meta-language: a language that allows us to create or define other languages. For example, with XML we can create other languages, such as RSS, MathML (a mathematical markup language), and even tools like XSLT. More on this later.

A very well known example is HTML (HyperText Markup Language). Websites are coded in HTML (and other programming languages), however, you (should) never see a trace of the code. What you do see is its interpretation by the browser, for example a certain font formatting, a table, or embedded images. So what does XML do?

Let me start at the very beginning. XML is a more recent language similar to HTML, but it allows for more flexibility. Like HTML it is a simplified subset of SGML (Standard Generalized Markup Language), the mother of all markup languages. Per definition, XML is a universal format for structured documents and data on the web. In other words, it is used to markup or describe data.

To achieve this description of data, XML relies on Document Type Definition (DTD). You could say that this is the ‘machine’s’ dictionary, which allows it to understand the markup language. Thus, each document must start by defining the type of DTD to be used. The code could look something like this:

 <!doctype html public “-//w3c//DTD html 4.0//en”>

This specific example tells the ‘machine’, in this case a browser, that the DTD is html 4.0 in English. The browser can then go ahead and compare each of the given commands with its DTD, which in turn tells it what to do with that command. That’s how the command <b> translates to bold text or <u> to underlined text.

Now that was a HTML example and probably doesn’t instantly bring you any closer to understanding XML. Hang on, we’re getting there, but not without looking at HTML a little bit more. The problem with HTML is that it consists of a static set of commands and whenever you need to give certain attributions, you need to type these commands. Over and over again. In other words, HTML is very simple, very obvious, easy to learn, but also not very flexible.

Let me give you an example. Say you want to change the size or color of a header you have used a dozen times throughout your website. That can be quite annoying. To circumvent this tiresome editing of HTML documents, style sheets were invented. Now you simply call your header a ‘header 1′ in your website and in the style sheet you define what a ‘header 1′ looks like. So when you want to change your header, you only change it in one place, i.e. the style sheet. Problem solved.

XML works similar to a style sheet. Yes, now we’re getting there! It’s more flexible than HTML because it lets you create your own building blocks. An XML document basically is a type of style sheet that defines how its subordinate documents are to be read by the ‘machine’. Of course there is a crucial difference to HTML and style sheets. You basically skip the HTML because you create your own DTD and the whole process is simplified. Essentially, the command definition is outsourced to the DTD.

There are two types of XML files. The first relies on the standard DTD that the ‘machine’, e.g. a browser can read. The second allows you to write your own DTD and create your own command building blocks. So you could become really creative and then provide the ‘machine’ with both your XML and your very own DTD file.

Now another extremely important difference between HTML and XML is that HTML defines how data look, while XML defines what data is. This should make clear that XML does not replace HTML, rather it extends it. In essence, XML doesn’t really do anything, but structure, store, and transport data. Bummer.

So what XML is used for, is to outsource data. Rather than integrating them into the HTML document, they are stored in separate XML files. Since XML stores data in plain text format, the storage is independent of your platform and your data can be exported, imported, or simply moved much easier.

Many other languages are based on XML, including XHTML, WAP for hand held devices, or RSS for feeds. And here we have reached some actual uses of XML, as well as the end of this article.

An Example XML Document:

XML documents use a self-describing and simple syntax:

 <?xml version="1.0" encoding="UTF-8"?>  
 <note>  
  <to>Tove</to>  
  <from>Jani</from>  
  <heading>Reminder</heading>  
  <body>Don't forget me this weekend!</body>  
 </note>

The first line is the XML declaration. It defines the XML version (1.0).
The next line describes the root element of the document (like saying: "this document is a note"):
```
 <note>  
```

The next 4 lines describe 4 child elements of the root (to, from, heading, and body):

 <to>Tove</to>  
 <from>Jani</from>  
 <heading>Reminder</heading>  
 <body>Don't forget me this weekend!</body>

And finally the last line defines the end of the root element:
```
 </note>  
```

You can assume, from this example, that the XML document contains a note to Tove from Jani.
Don't you agree that XML is pretty self-descriptive?

Representation State Transfer (REST)

2015-02-03T05:22:00.001-08:00

Universal Description, Discovery, and Integration (UDDI)

2015-02-03T05:21:00.001-08:00

Simple Object Access Protocol (SOAP)

2015-02-03T05:20:00.001-08:00

Service Oriented Architecture (SOA)

2015-02-03T05:19:00.003-08:00

Web Services Description Language (WSDL)

2015-02-03T05:19:00.001-08:00

Web Services

2015-02-03T05:18:00.002-08:00