View
37
Download
0
Category
Preview:
Citation preview
5/13/2018 Developing Custom Mediations for WebSphere Enterprise Service Bus - slidepdf.com
http://slidepdf.com/reader/full/developing-custom-mediations-for-websphere-enterprise-servi
Sign in (or registeEnglish
Technical topics Evaluation software Community Events
Nigel Daniels (daniels@uk.ibm.com), Staff Software Engineer, WebSphere PlatformMessaging, IBM
Summary: This article introduces the use of custom mediations using the WebSphere
Integration Developer V6 environment for WebSphere Enterprise Service Bus V6. The article
will walk you through the development of three types of custom mediations in a simple
scenario.
Tag this! Update My dW interests (Log in | What's this?)
Date: 11 Jan 2006Level: Intermediate
Also available in: Chinese
Activity: 9472 views
Comments:
developerWorks WebSphere Technical library
Introduction
This article will show you how to develop custom mediation components using IBM® WebSphere® Integration Developer V6.0.1
and WebSphere Enterprise Service Bus V6.0.1 (hereafter called WebSphere ESB). The article will show you how to construct amediation module, and describe the three types of custom mediation.
To make best use of this article, you should be familiar with Java™, and have some knowledge of the WebSphere Integration
Developer development environment and IBM Service Component Architecture (SCA). The examples in this article were
developed using WebSphere Integration Developer and deployed on WebSphere ESB. The examples can also be written for and
deployed on WebSphere Process Server V6.0.1.
A custom mediation primitive enables a business integrator to add Java processing capabilities to a mediation flow. Although there
are three ways to construct a custom mediation, they all function in a similar fashion. The custom mediation enables the flow to
call out from the running flow to a Java component in the SCA assembly that contains the flow:
Figure 1. How a custom mediation works
In Figure 1, the mediation component (ProviderMediation) in the assembly diagram contains the "zoomed-in" flow in the lower part
of the graphic. The mediation component makes a reference to the Java component (ProviderComponent), but it is the custom
mediation primitive "within" the mediation component that makes use of the Java component via the reference.
As mentioned, there are three ways to create custom mediations:
1. A custom mediation with a user-created interface and implementation. This type of custom mediation can have limitations
unless it is carefully crafted.
2. A custom mediation with a fully generated interface and implementation. This type of custom mediation lets you create
code in situ using the Snippet Editor or the Visual Java Editor.
3. A custom mediation with a generated interface only. In this type of custom mediation, you must create the mediation using
a standard Java editor.
This article will show you how to use a user-created mediation in the DateProvider project. This project will be used as though it
were an external service in the DateService project, and this project will demonstrate the use of the other two types of custom
mediation.
Table of contents
Introduction
Creating custom mediatio
Testing the flows
Conclusion
Download
Resources
About the author
Comments
Next steps from IBM
Try: WebSphere IntegratioDeveloper (in the SOA Sa
Connect)
Demo: Process automatioadoption pattern
Briefing: WebSphere flexibusiness processes
Buy: WebSphere IntegratDeveloper (in the SOA SaConnect)
Dig deeper into WebSphe
developerWorks
Overview
New to WebSphere
Products
Downloads
Technical library (articles
tutorials, and more)
Community and forums
Events
Newsletter
Discover knowledge paths
Developing custom mediations for WebSphere Enterprise Service Bus
Search developerW
5/13/2018 Developing Custom Mediations for WebSphere Enterprise Service Bus - slidepdf.com
http://slidepdf.com/reader/full/developing-custom-mediations-for-websphere-enterprise-servi
Creating custom mediations
Setting up your development environment
To follow the instructions in this article, you need to ensure that your development environment is configured correctly. In
WebSphere Integration Developer, start by selecting Window => Preferences to open the Preferences dialog.
Workbench setup
Under the Workbench section, select Capabilities and ensure that all of the Web Service Developer options are checked. This
is not required to develop custom mediations, but the Web Services Explorer will be used when testing the flow.
Server setup
In the Server section of Preferences, select Installed Runtimes and ensure that WebSphere ESB Server V6.0 is the default
server.
JRE setup
Under the Java section, under Installed JREs, ensure that the default JRE is set to use the WebSphere ESB Server V6.0 JRE.
The Provider project
To show you how to use custom mediations, we will walk through generating each type of mediation, starting with the user-
generated version. To demonstrate this form of custom mediation, we will create a flow that accepts date based on
java.util.Date and responds with a number representing a day of the week, with 1=Sunday, 2=Monday, and so on to
7=Saturday. The project is made up of the following steps:
Creating the library
Creating the assembly
Creating the flow
Creating the library
Before creating the assembly, we need to create a Library Project, which will be used to hold the interface we will use. This
interface will be reused in a later project; hence the need for a shared Library Project. To create it, right-click the Business
Integration view and select New => Library. In the New Library wizard, set the Name to DateLibrary and click Finish.
Having created the DateLibrary, right-click on the Interfaces section of the DateLibrary and select New => Interface. In the
New Interface wizard, set the Name to DateProvider and click Finish, which will generate the new interface and open the
Interface Editor.
In the Interface Editor create, an operation called getDayOfWeek. On the operation, set an input called date of type date and an
output called day of type int. The final result should look like Figure 2:
Figure 2. Date Provider interface.
Creating the assembly
To create the assembly, right-click on the Business Integration view and select New => Mediation Module. In the New Mediation
Module wizard, set the module Name to DateProvider, leave all of the other defaults, and click Next>. In the next panel of the
wizard, you can choose the libraries that the module references. In this case we need to be able to refer to the DateProvider
interface that we just created. Check the box next to DateLibrary and then click Finish, which will create a new mediation
module.
Double-click the assembly diagram and rename the mediation component from Mediation1 to ProviderMediation. Then addthe DateProvider interface to the component. Add an Export component and name it ProviderExport, then again add the
DateProvider interface. Right-click it again and set the export binding to be an SCA binding. Now select a Java Component
from the pallet and add it to the canvas, and again add the interface DateProvider to the component. This time the dialogue will
also show Java classes, so filter the view to Web Service Description Language (WSDL) files. Rename the component from
Component1 to ProviderComponent.
Finally, select the wire tool and wire the ProviderExport to the ProviderMediation and the ProviderMediation to the
ProviderComponent. A dialog will ask A matching reference will be created on the source node. Do you
want to continue?. Click OK. When the link is made, a box marked 1..1 appears on the ProviderMediation. This box
indicates the reference to a Java component is available to the mediation component. The resulting assembly should look like this:
Figure 3. Date Provider Assembly.
Skill-building guides for
WebSphere, Linux, open
source, cloud, Java, bus
analytics, and more.
Special offers
Trial software offers
5/13/2018 Developing Custom Mediations for WebSphere Enterprise Service Bus - slidepdf.com
http://slidepdf.com/reader/full/developing-custom-mediations-for-websphere-enterprise-servi
Save the assembly you have created so far. The blue circles containing exclamation marks on ProviderMediation and
ProviderComponent indicate that the Flow and Java components require implementations.
Creating the Java component
To create the implementation behind the ProviderComponent, double-click on the component. When asked Would you like
to implement the component now? , click Yes. The next dialog has an option to create a package for the Java code that will
be generated. Click New Package and in the New Package dialog, set the package name to com.ibm.dateprovider. On
return to the Generate Implementation dialog, select the new package and click OK.
The generated class DateProviderImpl will open in the Java Editor. This class is simple and is referred to by the Java
component. Comments explain what the methods do. Here is the method that needs to be modified:
Listing 1. Date Provider method
Replace the contents of the getDayOfWeek method with the code in Listing 2:
Listing 2. Date Provider code
After saving and closing the Java Editor, the Java component will no longer be marked as requiring implementation.
Creating the flow
Double-click on the ProviderMediation flow component. When asked The selected component is not yet
implemented. Would you like to implement the component now? , click Yes. The next dialog asks where to
generate the implementation. Click OK to accept the default location of the DateProvider project root.
The Mediation Flow Editor opens. It has two panes, with the properties view playing an important role in the lower pane. The upper
pane indicates the interface operation you are working on, and the lower pane shows the flows associated with that operation. We
will create a simple request/response flow for the single operation on the DateProvider interface. Select the operation
getDayOfWeek and the lower Request pane will show the two available nodes -- the Input node for the operation and the Input
Response node. Since we are not associating the operation with any external services, we do not see any Callout nodes to wire
to. For our purposes, this is all we need, as we will be "looping back" any incoming message after passing it through the custom
mediation.
To add a custom mediation to the canvas, select a custom mediation from the flow pallet and click on the blank canvas. Rename
the custom mediation from CustomMediation1 to ProviderMediation. Select the Input node's Out terminal and wire it to the
In terminal of ProviderMediation. Then wire the ProviderMediation Out to the In on the Input Response node. The
resulting flow should look like this:
Figure 4. Date Provider Flow
/**
* Method generated to support implementation of operation
* "getDayOfWeek" defined for WSDL port type named
* "interface.DateProvider".
*
* Please refer to the WSDL Definition for more information
* on the type of input, output and faults).
*/
public Integer getDayOfWeek(Object date) {
//TODO Needs to be implemented.
return null;}
System.out.println("ProviderComponentImpl - getDayOfWeek : Mediation Called");
// Use a GregorianCalendar to get the day of the week
System.out.println("ProviderComponentImpl - getDayOfWeek : Setting GregorianCalendar to using date
[" + ((Date)date) + "]");
GregorianCalendar calendar = new GregorianCalendar();
calendar.setTime((Date) date);
System.out.println("ProviderComponentImpl - getDayOfWeek : Setting calendar is [" + calendar + "]");
//Return the day of the week
System.out.println("ProviderComponentImpl - getDayOfWeek : Returning the day of week as "
+ calendar.get(java.util.Calendar.DAY_OF_WEEK));
return new Integer(calendar.get(java.util.Calendar.DAY_OF_WEEK));
5/13/2018 Developing Custom Mediations for WebSphere Enterprise Service Bus - slidepdf.com
http://slidepdf.com/reader/full/developing-custom-mediations-for-websphere-enterprise-servi
When generating a custom mediation and basing it on a
user-provided flow, the Custom Mediation Wizard
assumes that the request is the input message and the
response is the output message. Thus, direct use of this
type of custom mediation is easiest to use in
request/response flow where the same interface has
been used on the export.
If this were a response flow, the request message would
be selected as the input and the response message
would be set as the output, but the surrounding nodes
would be expecting response messages only. The
inverse is true for request messages. By carefully
crafting the interface and possibly using XSLT Mediation
Primitives, you can work around this problem. When
embedding in a complex flow, this problem is probably
not an issue.
Next, associate ProviderMediation with the interface we created earlier, which links the Java Component in the assembly
diagram to the custom mediation that we are creating. Select ProviderMediation, and in the properties view below, select the
Details tab:
Figure 5. Custom mediation properties -- Details.
The Details tab shows the error Service operation: cannot
be empty. To correct this error, click Define to open the Define
Custom Mediation dialog, In the first panel, set the option Choose an
existing interface so you can set the interface we have made. Click
Next>, then click Browse to select the interface DateProvider.
Then select the Operation drop-down to select the operationgetDayOfWeek. The Input Message and Output Message displays
are automatically set to the request and response messages found
on the operation. Click Finish .
Now that we have defined the custom mediation and its interface, the
flow is complete. Save the flow. The assembly is now also complete.
The Service project
The mediation module we have just generated accepts a date as
input and responds with a number representing the day of the week
that that date falls on. Now let's put this "service" into a common
context in which custom mediations are used. Assume that a Web
client wants to use this service and will obtain the date information
from a user in the form of an independent day, month, and year. The required response will be a string representation of the day of
the week:
Figure 6. Message mismatch.
In order to resolve the mismatch of the message types in the above scenario, we can use WebSphere ESB and custom
mediations. In order to implement this project, we will need to perform the following steps:
Creating the interface
5/13/2018 Developing Custom Mediations for WebSphere Enterprise Service Bus - slidepdf.com
http://slidepdf.com/reader/full/developing-custom-mediations-for-websphere-enterprise-servi
Creating the assembly
Mapping the operation
Creating the request flow
Creating the response flow
Creating the component
Creating the interface
The first thing that is required is to create a mediation module project. Name it DateService and again ensure that it has
reference to the DateLibrary, as it contains the interface that we will be calling on. After this is generated, create a Business
Object data type to hold the input day, month. and year. Right-click on the Data Types section of the DateService project and
select New => Business Object. In the New Business Object Wizard, set the name to DateBO and click Finish. The Business
Object Editor will open and display the DateBO object. Select the Add as attribute to a business object icon and add the firstattribute. A new attribute will be created. Change the name from attribute1 to day and set the type to int. Repeat this
process and add the attributes month and year. The final Business Object should look like this:
Figure 7. DateBO Business Object.
Now that the Business Object that will hold the input data has been created, generate the interface that will be used by the
DateService:
Figure 8. Date Service interface.
Creating the assembly
Now all of the parts are in place to begin creating the DateService assembly. There are two stages, and in this first stage we will
create the basic assembly shown below in Figure 9. Later we will generate the Java Components we need. Double-click the
DateService assembly to open it in the Assembly Editor. Rename the Mediation component to ServiceMediation and assign
it the DateService interface. Then add an Import and an Export component to the canvas and name them ServiceImport and
ServiceExport respectively.
Starting with the Import, this needs to be configured to refer to the ProviderExport created in the DateProvider project. First,
assign this component the DateProvider interface from the shared library, and set the binding for the component to an SCA
Binding. Now that this component has the same binding type as the Export that we wish to target, right-click the component and
select Select Service To Import. In the SCA Export Selection dialogue, select ProviderExport. This import will now refer to the
export we created earlier and will ultimately let us use the custom mediation in that module, thus using the DateProvider as a
substitute for an external service. In a real world situation, you would probably not import an interface to an external service such
as an existing Web service or JMS application.
The next item to edit on the canvas is the export. Assign the DateService interface to the component. Then assign a Web
Service Binding to the export. In response to the question Should we automatically generate a WSDL file with
binding/service/port elements defined inside for you? , click Yes. In the Select Transport dialogue, select
SOAP/HTTP as the transport. It is needed later to act as the client when we test the file using the Web Service Explorer. Note that
the Web Service Ports section appears in the DateService project. This section should now contain the file
ServiceExport_DateServiceHttpPort.
The final task is to wire the assembly. Wire the export to the mediation component and the mediation component to the import.
When asked about interfaces and references, click OK. When you are done, remember to choose the Selection tool on the pallet
so that you get out of the wiring mode. Save the file and it should look like this:
Figure 9. Service Assembly Creation - Stage One.
Mapping the operations
5/13/2018 Developing Custom Mediations for WebSphere Enterprise Service Bus - slidepdf.com
http://slidepdf.com/reader/full/developing-custom-mediations-for-websphere-enterprise-servi
After creating the assembly, we have wired together the incompatible interfaces. It is inside the mediation component that we will
use custom mediations in the request and response flows to transform the messages. From the Assembly Diagram, double-click
on ServiceMediation and open the Flow Editor. This time, the first thing to do is to associate the getDay operation with the
getDayOfWeek operation on the DateProviderPartner reference. To do this mouse over the getDay operation, select the
Create Operation Mapping handle, and drag it over to the getDayOfWeek operation on the DateProviderPartner reference.
This will result in an arrow indicating the mapping, as shown in Figure 10:
Figure 10. Service Flow Operation Mapping.
Notice that two things happen in the Flow Editor:
1. On the canvas, the Callout DateProviderPartner_getDayOfWeek_Callout appears.
2. A second tab Response :getDay appears.
Save the flow before continuing.
Creating the request flow
Let's start with the request flow. Is this half of the mediation that will handle the transformation of the input message (day, month,
year) into the input message (java.lang.Date) expected by the service we will call out to. Ensure that the Request: getDay tab
is selected and add a custom mediation to the canvas with the name RequestMediation. Wire DateService_getDay_Input
to RequestMediation, then wire RequestMediation to DateProviderPartner_getDayOfWeek_Callout . The incomingmessage on the request half of its journey will pass through the custom mediation and then onto the input of the
DateProviderPartner, which in turn is a reference to import in the assembly diagram. The final flow should look like this:
Figure 11. Service Flow -- Request :getDay.
Ignore the warning marker on the input response node (DateService_getDay_InputResponse) -- it is just warning us that the
node's terminal has not been connected. In this case we want the message to pass on to the next module and not to be returned
directly from this flow.
Now that the flow is configured, we can build the contents of the flow. Select RequestMediation and then in the Properties view
for the mediation, select the Details tab and click Define.
This time, leave Create a new interface with implementation selected and click Next>. In the following panel, you don't need to
change anything. The request messages in input getDayRequestMsg and output getDayOfWeekRequestMsg are the
messages we need to translate. In the next panel, change the Name from CustomMediation1 to RequestMediation and click
Next>. Finally, select Generate a default Java implementation class and define it using the embedded visual snippet editor
and click Finish. When the dialog closes, a RequestMediationPatner reference with the operation mediate appears in the
Operation connections panel of the Mediation Flow Editor. Also, the RequestMediation interface appears in the Interfaces
section of the DateService project in the Business Integration view.
Having set the interface that we will be using, we need to add the Java code to the Java Snippet. Select the Implementation tab
of the Properties view, as shown in Figure 12 below. By using the Java Snippet Editor, this form of mediation indicates
conceptually where the Java code resides, even though the code actually resides in a Java Component. The Snippet Editor has
some restrictions worth noting. It does not indicate errors in the Java Code, and when you add code that requires an import, don't
forget to press Ctrl+Shift+O to Organize Imports or fully qualify the classes you include.
While editing the code, if you need to get a better view of what is happening, click Open Java Editor to access the class
containing this code.
Figure 12. Custom Mediation Properties -- Implementation.
5/13/2018 Developing Custom Mediations for WebSphere Enterprise Service Bus - slidepdf.com
http://slidepdf.com/reader/full/developing-custom-mediations-for-websphere-enterprise-servi
If the code you entered does not appear to persist -- in
other words, if upon returning to the Snippet Editor you
just see return null; instead of the code you pasted
in -- then you can add the code directly to the class that
holds the Java snippet. Instead of accessing the code
via the Open Java Editor button, you need to go to
where this code actually resides. To do so, switch to the
Java perspective and look for the DateService
project. In it, find the package
sca.component.mediation.java.impl.
In this package are two classes,
RequestMediationPartner.java and
RequestMediationPatnerCustomLogic.java, the
second of which holds an inner class called
JavaSnippet, which is where the code we changed in
the Java Snippet Editor resides. In this inner class,
locate the method public DataObject
execute(DataObject a_type) and paste in thecode from above. Then press Ctrl+Shift+O to Organise
Imports and save the file. Then return to the Business
Integration Perspective and continue. This time the code
will persist.
In the snippet, add the code in Listing 3 to the code snippet section:
Listing 3. Java Snippet code
At this point, save the flow created so far. An error marker appears on
the project we are working on. What has gone wrong? The error is
associated with the assembly diagram with the message "The
mediation flow implementation 'ServiceMediation.mfc' contains areference 'ResponseMediationPartner' that does not match a
corresponding reference in the mediation flow component."
Recall that the introduction described the custom mediation within the
flow using a reference to call out of the flow to a component in the
assembly diagram. In the first part of this exercise, we generated a
Java component and wired it to the mediation component to create a
reference. In this case, we have generated the custom mediation, the
Java code, and the reference. However, the component that the
reference is looking for does not yet exist on the assembly diagram.
You can ignore this error for now because we will correct it in the the
last stage of the exercise.
Creating the response flow
Next, fill in the other half of the mediation flow. The job of thistransformation is to take the response message from our "external"
service (an int representing the day of the week) and turn it into the
response expected by our own interface (a java.lang.String
version of the day of the week).This time select the Response
:getDay tab in the Mediation Flow Editor and as you did above, add a
custom mediation. Name the mediation ResponseMediation and
wire it into the flow. The resulting flow should look like this:
Figure 13. Service Flow -- Response :getDay
System.out.println("RequestMediation : Mediation called");
System.out.println("RequestMediation : Getting BOFactory");
ServiceManager serviceManager = ServiceManager.INSTANCE;
BOFactory bofactory = (BOFactory) serviceManager.locateService("com/ibm/websphere/bo/BOFactory");
System.out.println("RequestMediation : Getting dateBO");
DataObject dateBO = a_type.getDataObject("dateBO");
System.out.println("RequestMediation : Create date from [" + dateBO.getInt("year") + ", "
+ dateBO.getInt("month")+ ", "
+ dateBO.getInt("day") + "]");
GregorianCalendar calendar = new GregorianCalendar(dateBO.getInt("year"),
dateBO.getInt("month")-1,
dateBO.getInt("day"));
System.out.println("RequestMediation : Create DataObject
http://DateLibrary/DateProvider/getDayOfWeek");
DataObject getDayOfWeek = bofactory.createByElement("http://DateLibrary/DateProvider",
"getDayOfWeek");
System.out.println("RequestMediation : Set getDayOfWeek date attribute");
getDayOfWeek.setDate("date", calendar.getTime());
System.out.println("RequestMediation : Return date getDayOfWeek");
return getDayOfWeek;
5/13/2018 Developing Custom Mediations for WebSphere Enterprise Service Bus - slidepdf.com
http://slidepdf.com/reader/full/developing-custom-mediations-for-websphere-enterprise-servi
On the properties view of ResponseMediation, go to the Details tab and click Define. Again, select Create a new interface
with implementation => Next>. Click through the following panel, and in the next panel change Name from CustomMediation1
to ResponseMediation. Then click Next>. In the last panel, select Specify the implementation manually as Java component
or Import in the Assembly Editor -- default Java Implementation will not be generated and click Finish .
ResponseMediationPartner appears in the Operation connections panel of the Mediation Flow Editor and an associated
ResponseMediation interface is generated in the project. Save the flow. You may notice that another error similar to the one we
had for the request flow appears. It is now time to fix these errors.
Creating the Java components
Open the Assembly diagram and right-lick on ServiceMediation and select Merge Implementation. You will be asked Do
you want to merge the new implementation with the existing one? . Click OK. A dialog will open that shows the
Reference being used, the interface that the reference uses, and a check box to indicate that a Java Component will be created.Click OK again, which switches you back to the Flow Diagram. Return to the Assembly Diagram Editor and you should see two
new components. Click Arrange Contents Automatically and the diagram should look like this:
Figure 14. Service Assembly Creation -- Stage Two.
These two Java components are what the mediations we have created will call out to from the flow. The
ResponseMediationPatner is marked as requiring an implementation. Recall that during the flow creation, we added code to
the request flow. If the code had problems persisting, then you saw where the implementation for this Java component resides.
To implement the ResponseMediationPartner, follow the same steps as when implementing the ProviderComponent, but
this time set the package to be com.ibm.dateservice and add the code in Listing 4 to the method public DataObject
mediate(DataObject a_type):
Listing 4. Response mediation partner code
System.out.println("ResponseComponentImpl - mediate : Mediation Called");
StringBuffer dayOfWeek = new StringBuffer();
System.out.println("ResponseComponentImpl - mediate : Getting the day number");
int day = a_type.getInt("day");
//Decide which day of the week it is
System.out.println("ResponseComponentImpl - mediate : Decide day of week on value [" + day + "]");
switch (day) {
case 1: {
dayOfWeek.append("Sunday");
break;}
case 2: {
dayOfWeek.append("Monday");
break;}
case 3: {
dayOfWeek.append("Tuesday");
break;}
case 4: {
dayOfWeek.append("Wednesday");
break;}
case 5: {dayOfWeek.append("Thursday");
break;}
case 6: {
dayOfWeek.append("Friday");
break;}
case 7: {
dayOfWeek.append("Saturday");
break;}
default : {
dayOfWeek.append("Day could not be calculated");
break;}
}
System.out.println("ResponseComponentImpl - mediate : Getting BOFactory");
ServiceManager serviceManager = ServiceManager.INSTANCE;
BOFactory bofactory = (BOFactory) serviceManager.locateService("com/ibm/websphere/bo/BOFactory");
5/13/2018 Developing Custom Mediations for WebSphere Enterprise Service Bus - slidepdf.com
http://slidepdf.com/reader/full/developing-custom-mediations-for-websphere-enterprise-servi
Save the Java code that you have just added and return to the Assembly Diagram Editor and save that as well. Theimplementation marker will disappear. The mediation flow is complete, and you are now able to deploy this flow and test it using
the Web Services Explorer.
Testing the flows
First, go to the Servers view in the Business Integration perspective. If you have not yet created a server, right-click the view pane
and select New => Server. In the New Server dialog, select WebSphere ESB Server V6.0 and then click Finish. WebSphere
ESB Server V6.0 localhost will appear in the Servers View. If the server you are targeting is remote, then it will say
something other than localhost. Select the new server and ensure that it is started. This may take awhile, but eventually in the
Console View you will see:
In the Server View, the server should have a "started" status:
Figure 15. Started server
Return to the Servers View and select the ESB server. Right-click the server and select Add and remove projects, which will
show you a dialog with a view of the projects available for deployment and those deployed. Ensure that the DateProvider and
the DateService projects are added to the server. Click Finish.
Once the projects have been published on the server they are ready for testing. Switch to the Java perspective. Recall that when
we created an export for the DateService project, we created a Web service binding on the export and set it to use the
SOAP/HTTP transport. When this was done, a WSDL file was generated for us with all of the binding/service/ports defined. We will
use this WSDL file in the Web Service Explorer to test out our newly deployed flows.
In the Java perspective, use the Package Explorer to locate the DateService project. In the root of this project, find the
ServiceExport_DateServiceHttp_Service.wsdl file that we will use for testing. Right-click the WSDL file and select Web
Services => Test with Web Services Explorer. The Web Service Explorer browser will open and will be looking at the file we
selected. In the operations section, click the getDay link to go to the Invoke a WSDL Operation page. Here each of the parts of
the dateBO are visible -- day, month, and year. For each one, select Add and enter an appropriate value, such as day=1,
month=1, year=1970. Then click Go, which sends the date data to the server where the flow has been deployed. After this data
has been processed, the Status panel below will change and display the getDayResponse message and the value of
dayOfWeek. For example, given the date above, the response will be Thursday:
Figure 16. Web Service Explorer.
System.out.println("ResponseComponentImpl - mediate : Create DataObject
http://DateService/DateService/getDayOfWeek");
DataObject getDay = bofactory.createByElement("http://DateService/DateService",
"getDayResponse");
System.out.println("ResponseComponentImpl - mediate : Set dayOfWeek string to ["
+ dayOfWeek.toString() + "]");
getDay.setString("dayOfWeek", dayOfWeek.toString());
System.out.println("ResponseComponentImpl - mediate : Returning getDay");
return getDay;
[31/12/05 16:26:08:109 GMT] 0000000a WsServerImpl A WSVR0001I:
Server server1 open for e-business
5/13/2018 Developing Custom Mediations for WebSphere Enterprise Service Bus - slidepdf.com
http://slidepdf.com/reader/full/developing-custom-mediations-for-websphere-enterprise-servi
As further evidence of the flow running, in the console you will see the output from the System.out.println(); lines in the
Java code we added. These allow us to see the messages at various stages of processing:
Listing 5. Console output
[29/12/05 17:14:44:688 GMT] 00000051 SystemOut O RequestMediation : Mediation called
[29/12/05 17:14:44:688 GMT] 00000051 SystemOut O RequestMediation : Getting BOFactory
[29/12/05 17:14:44:703 GMT] 00000051 SystemOut O RequestMediation : Getting dateBO
[29/12/05 17:14:44:703 GMT] 00000051 SystemOut O RequestMediation : Create date from[1970, 1, 1]
[29/12/05 17:14:44:703 GMT] 00000051 SystemOut O RequestMediation : Create DataObject
http://DateLibrary/DateProvider/getDayOfWeek
[29/12/05 17:14:44:703 GMT] 00000051 SystemOut O RequestMediation : Set getDayOfWeek date
attribute
[29/12/05 17:14:44:703 GMT] 00000051 SystemOut O RequestMediation : Return date getDayOfWeek
[29/12/05 17:14:45:156 GMT] 00000051 SystemOut O ProviderComponentImpl - getDayOfWeek :
Mediation Called
[29/12/05 17:14:45:156 GMT] 00000051 SystemOut O ProviderComponentImpl - getDayOfWeek :
Setting GregorianCalendar to using date
[Thu Jan 01 00:00:00 GMT 1970]
[29/12/05 17:14:45:156 GMT] 00000051 SystemOut O ProviderComponentImpl - getDayOfWeek :
Setting calendar is
[java.util.GregorianCalendar
[time=-3600000,
areFieldsSet=true,
5/13/2018 Developing Custom Mediations for WebSphere Enterprise Service Bus - slidepdf.com
http://slidepdf.com/reader/full/developing-custom-mediations-for-websphere-enterprise-servi
Conclusion
WebSphere ESB Server V6.0.1 comes with a good basic pallet of mediation primitives and has an easy-to-use interface which lets
you quickly integrate different interfaces. However, there are always applications or interfaces that do not fit together as nicely as
we would like. This article has shown how custom mediations let the Business Integrator add Java code to handle these cases. By
creating the case where the interface does not match nicely, you have seen just how quickly and easily custom mediation lets you
solve this problem.
I hope this article has let you see how powerful custom mediations are. In addition to the situation described here, custom
mediations let you add code to manipulate messages in many ways, adding business logic as needed. For example, you can use
them to call complex JDBC queries, generate new messages, or manipulate message body content or headers in ways that XSLT
cannot manage. The possibilities are as diverse as the applications problems you need to solve.
Back to top
Download
Description Name Size Download method
Code samples in zip format CustomMediations.zip 269 KB FTP | HTTP
Information about download methods
Resources
WebSphere Enterprise Service Bus product page
Product descriptions, product news, training information, support information, and more.
WebSphere Integration Developer product page
Product descriptions, product news, training information, support information, and more.
WebSphere Business Process Management V6 Information Center
Documentation for WebSphere Business Modeler V6, WebSphere Integration Developer V6, WebSphere Enterprise
Service Bus V6, and WebSphere Process Server V6.
Specifications for Service Component Architecture (SCA) and Service Data Objects (SDO)
In addition to IBM, contributors include BEA Systems, IONA, Oracle, SAP AG, Siebel Systems, Sybase, and Xcalia.
IBM Service-Oriented Architecture (SOA) page
General information and resources related to SOA.
Eclipse Modeling Framework documents
A great reference for SDO programming.
WebSphere Business Integration products page
For both business and technical users, a handy overview of all WebSphere Business Integration products
developerWorks WebSphere Business Integration zone
For developers, access to WebSphere Business Integration how-to articles, downloads, tutorials, education, product info,
and more.
areAllFieldsSet=true,
...
MILLISECOND=0,
ZONE_OFFSET=3600000,
DST_OFFSET=0]]
[29/12/05 17:14:45:156 GMT] 00000051 SystemOut O ProviderComponentImpl - getDayOfWeek :
Returning the day of week as 5
[29/12/05 17:14:45:188 GMT] 00000051 SystemOut O ResponseComponentImpl - mediate :
Mediation Called
[29/12/05 17:14:45:188 GMT] 00000051 SystemOut O ResponseComponentImpl - mediate :
Getting the day number
[29/12/05 17:14:45:188 GMT] 00000051 SystemOut O ResponseComponentImpl - mediate :
Decide day of week on value [5]
[29/12/05 17:14:45:188 GMT] 00000051 SystemOut O ResponseComponentImpl - mediate :
Getting BOFactory[29/12/05 17:14:45:188 GMT] 00000051 SystemOut O ResponseComponentImpl - mediate :
Create DataObject
http://DateService/DateService/getDayOfWeek
[29/12/05 17:14:45:188 GMT] 00000051 SystemOut O ResponseComponentImpl - mediate :
Set dayOfWeek string to [Thursday]
[29/12/05 17:14:45:188 GMT] 00000051 SystemOut O ResponseComponentImpl - mediate :
Returning getDay
5/13/2018 Developing Custom Mediations for WebSphere Enterprise Service Bus - slidepdf.com
http://slidepdf.com/reader/full/developing-custom-mediations-for-websphere-enterprise-servi
About
Help
Contact us
Submit content
Feeds and apps
Newsletters
Report abuse
Terms of use
IBM privacy
IBM accessibility
Faculty
Students
Business Partners
Print this page Share this page Follow developerWorks
Trial downloads for IBM software products
No-charge trial downloads for selected IBM® DB2®, Lotus®, Rational®, Tivoli®, and WebSphere® products.
Most popular WebSphere trial downloads
No-charge trial downloads for key WebSphere products.
Safari Bookshelf: e-library designed for developers
Complete search and download access to thousands of technical books for a one-time subscription fee. Free trial for new
subscribers.
WebSphere forums Product-specific forums where you can ask questions and share your opinions with other WebSphere users.
developerWorks blogs
Ongoing, free-form columns by software experts, to which you can add your comments. Check out Grady Booch's blog on
software architecture.
About the author
Nigel Daniels is a Staff Software Engineer at the IBM Hursley Software Lab in the UK, and Team Leader for
WebSphere ESB functional testing. Prior to joining IBM Hursley in 2003, he had over 10 years of wide-ranging IT
industry experience. His expertise includes object-oriented (OO) design and development of products and
applications, Eclipse and Java development, and software testing. He is a certified software tester and holds a
Masters degree in OO Software Technology from Brighton University in the UK. You can contact Nigel at
ndaniels@uk.ibm.com.
Rate this article
Comments
Back to top
Recommended