With every new language and new frameworks, systems developed today are getting extremely complex to understand. Buzz words like cross cutting concerns, separation of concerns and distributed applications are just adding complexity to the problems. Over past few years, development of large scale applications required development of various subsystems and integrating those systems to achieve common organisational goal.
It is always noticed that big organisations carry out their daily business operations on various systems developed and deployed on heterogeneous platforms and technology. Integration is required not for just, the in-house applications but geographically distributed business requires interfacing with subsystems spread across the globe. While it is not always possible to replace legacy systems, organisations are always looking to build new systems that can interface with old systems and carry out business process.
The problem of making systems communicate with each other is always crucial for growth and to carry out business activities smoothly. Well, that is where Enterprise Integration plays vital role.
A need was felt to have common language that can address enterprise level problem and help to built better software. Enterprise Integration patterns were the step towards building that common vocabulary. The patterns address most of the issues faced while building communication link between various systems.
Though Enterprise Integration patterns provide theoretical solution to the enterprise level problems, there was no readymade software available to address all above concerns.

Enterprise Service Bus
To address the Integration issues, a strong need was felt to have software that can help systems to communicate with each other and abstract the underlying protocol required for communication. Enterprise Service Bus was invented to address this concern and gained popularity within less time. There are many vendors providing their own ESB implementation helping business to integrate the systems.
Though ESB seems to be perfect choice for implementing Enterprise Integration, it has certain drawbacks like efforts required to implement a solution, most of the ESB use XML as data format for communication – require additional overhead to process the message, high hardware configuration requirements etc. On top of all, what If I am interested only in few Integration mechanisms and don’t want to use all nice to have features of ESB. In simple terms, can I get only features I am interested in and not whole ESB?

Any other option?
Well, over last few years’ communities like Mule Soft has been successful in implementing ESB that provide numerous features by keeping the complexity low.
In Jan 2008, there was one more project announced by a popular community in Java World – SpringSource. The aim of this project was to use similar techniques used by the leading Java AOP Framework – Spring and extending it further in Enterprise world. The framework is known as Spring Integration.

SPRING INTEGRATION
Integrating systems could be a complex task and it could be even more complex when it is developed and deployed on heterogeneous platforms. In enterprise world, system integration is typically done via messaging, file uploads, webservices etc. But using any of the means soon tend to become complex and require too much of development effort and understanding of how the connectors actually work. Developers need to understand the Integration design and should have capability to build a model which can be easily customized as per the requirements.
Spring integration framework is built to simplify the Enterprise integration with minimal coding and high flexibility. With the help of Spring Integration framework one can develop components that adheres to separation of concern principle and develop integration code with low or no coupling.
Let’s consider a scenario wherein two systems need to exchange a data via messaging. Following are the brief details about the scenario
1. System “A” does some processing and puts messages in Message Queue “MyQueue” (Message Queue is created on Apache Active MQ Server.)
2. Whenever a message is received in Queue (MyQueue) it should be transmitted to Queue “queue/C” (Message Queue is created on JBoss MQ server.)
In above scenario, using J2EE one can write a Message Driven Bean and receive messages stored on Queue “MyQueue”. The messages can be later transferred to destination Queue “queue/C” by using JNDI object and messaging API. Though this sounds simple, it would certainly require some effort from development side to write Java Code.
With the help of Spring Integration, there is no need to write a single line of Java code to develop above functionality. All of the above functionality can be achieved merely by writing few lines of XML. Just have a look at the next code (Don’t worry about what every line does.)

That’s all you require to achieve the above functionality. Set of XML tags and you are done. (Did I just say that you don’t need to write any java code, well if you want to see the above configuration running, you should write a bootstrap class which will load this configuration file OR you can deploy this as web application and load the above configuration file through context loader provided by SPRING.)

To run the sample, you should have following softwares
1. SPRING integration
2. SPRING 2.5 or above
3. Active MQ (You should create a queue as “sourceQueue”)
4. JBoss (In this example we will use default queue – queue/C)

The point I want to bring here is not about how I achieved this task by just using XML but the level of simplicity provided by Spring Integration framework. Though this is very simple use case, the configuration can be further extended to meet real-time project requirements.

WHAT NEXT
Well the example that I just explained is very simple, let’s consider following scenarios

Let’s evaluate above scenarios
1. To achieve functionality described in scenario 1, developer would require writing a component which checks if there is new email available in the mailbox. Developer need not have to worry about the scheduling activity as it is the built in feature available in Spring Integration framework (poller).
The additional functionality of retrieving policy details and sending new email with details can be coded in different components leading to loosely coupled design.
The component responsible for sending email with policy details would simply act on a logical channel. Also the component performing authorisation need not have to be aware of email sending component. Its primary responsibility is to just perform authentication of the given data (In this case it would be policy no and sender email address.)
2. For scenario 2, a component similar to what explained in scenario 1 can be implemented and by making use of poller feature, the new feed can be checked after specific interval. As and when the feed data is available the component has to just return value object holding data, the Spring integration framework will transmit data to a channel. This activity will lead to execution of one more component which would receive data as an input and can invoke webservice. Remember you can trigger multiple actions as and when any data is transferred to a channel and it can be easily configured using XML.

Let’s have a look at the following diagrams to understand the flow of operations for example 1.

The diagram indicates that the two components “Authentication” & “Email Sender” are invoked as soon as the data is available on the channels they are associated with. Note that the association between the components and channel is done through configuration and there is no hardcoded reference within components. (In this example any Java class capable of performing application specific operations are considered as component.)
Poller pings Email server at specific intervals to check if any email has arrived. If email contents matches to the criteria, required data is posted on channel1. Since Channel 1 is configured as input channel for Authentication component, the Authentication component will begin its execution. After the processing is complete, data returned by Authentication component can then be transferred to channel 2. There is no need to call any API from Authentication component to transfer data to channel 2. On receipt of data on channel 2 will lead to execution of Email Sender component. Following diagram shows logical flow of execution.

Components would be invoked only when there is appropriate message is available on channel. With patterns like “Transformer” and spring features like dependency injection, components would be never aware of the environment under which they are executed and would mostly work with POJO objects (Spring Integration framework can make use of all the Core-Spring framework features).
One of the advantage using Spring integration would be the solution can be built in quick time, without a need of application server, no need of high configuration hardware. Also the configuration is pretty simple and less painful. Developer doesn’t have to learn anything specific to application server or go through the process of wizard based configuration.
Let’s compare Spring integration with JEE to find out how it could be still a better choice.
To begin with, consider following set of questions and evaluate what both frameworks offer

WHAT’S INSIDE?
SPRING integration is messaging based framework and heavily uses “channel” as a base for transportation. Well though it is messaging based framework it is not tied to JMS. SPRING provides adapters for following
1. FTP
2. File
3. JMS
4. Webservices
5. Email
6. HTTP
7. Stream
8. RMI
Having support for all above connectors ensures that Spring integration framework can be used to connect to legacy as well as cutting edge technologies. Also both ends will never be aware of existence of each other.
Well SPRING integration is not just about transmitting data from one channel to another but it also provides implementation following patterns

Most of the above patterns are meant for Enterprise level integration and also considered as SOA patterns.
Most of you must have implemented solutions that require any of the above functionality. With SPRING integration it’s very easy to develop software that requires any of the above listed functionality.

Well there are few more utilities available in SPRING integration but this article would not be able to describe all of them.

CONCLUSION
Why SPRING Integration?
Anyone looking for integrating two or more systems which use different protocol for communication, SPRING integration looks better choice for development. Following can be attributed as basic reasons for same
1. SPRING integration can be extended and customized adapters can be built as per the requirements. (E.g. SFTP, SSH) Due to its open source nature, the chances of one already available on internet are high.
2. Like SPRING framework, SPRING integration doesn’t require any specific application server rather it can be executed as standalone application. Even if one uses application server, the Spring framework gives benefits of using platform specific features like transaction management.
3. There is also no need of any specific hardware requirement; SPRING integration is lightweight framework that can be deployed on any platform.
4. One can develop a set of components which are loosely coupled and can be executed on demand. (Invocation of component only when a data is available on specific channel. Components need not be aware of channels and can simply deal with POJO objects.)
5. Components can be individually tested and validated. No need of application server would also save great amount of development time spent on frequent stop/start of server. Developers can test the components right from their IDE of choice as standalone application.

REFERENCES
Impressed by SPRING integration project and want to explore more about it, well then here are the resources that helped me to gain knowledge about SPRING integration framework.
• http://www.springsource.org/spring-integration (You can download SPRING integration framework from this site.)
• http://blog.springsource.com/2009/02/13/982/
• http://www.parleys.com/display/PARLEYS/Home#slide=2;talk=29523990;title=Enterprise Integration Patterns with Spring (Well this site has plethora of information available in visual format. Do visit this site, you will always find something useful.)

No it’s not one more hate post against IBM websphere, but this time the target is BlazeDS. Few days back, we were facing problem while deploying Flex application on SSL. The environment used for the deployment was IBM websphere 6.1 with IBM JDK and windows 2008. As per BlazeDS documentation, there are very minimal configuration changes required to be done in services-config.xml and other XXX-config.xml files to use secure-amf channel.

As per the instruction the configuration was modified to use secure amf channel and the SWF files were recompiled with modified configuration settings. No error messages were displayed at the time of deployment and application startup, but we found strange error message after accessing the application URL. The browser was able to load the SWF and wrapper html file, but it was throwing an error message indicating that SunX509 trust manager is not available.
After enabling BlazeDS logging and careful observation of java stacktrace we found that the actual problem was with the TrustManager implementation of BlazeDS. The default implementation available with BlazeDS is – EasyX509TrustManager and have a look at the code defined for its constructor

public EasyX509TrustManager(KeyStore keystore)
    throws NoSuchAlgorithmException, KeyStoreException
  {
    TrustManagerFactory factory = TrustManagerFactory.getInstance("SunX509");
    factory.init(keystore);
    TrustManager[] trustmanagers = factory.getTrustManagers();
    if (trustmanagers.length == 0)
    {
      throw new NoSuchAlgorithmException("SunX509 trust manager not supported");
    }
    this.standardTrustManager = ((X509TrustManager)trustmanagers[0]);
    this.trustStore = (System.getProperty("flex.trustStore") != null);
  }

From above code it is quite clear that above code assumes that whole world uses only Sun JVM. While we found the culprit, the next step was to find a fix, so I simply googled “EasyX509TrustManager IBMX509″ and Voila, google returned only one entry with link to a java code

public EasyX509TrustManager(KeyStore keystore) throws NoSuchAlgorithmException, KeyStoreException
    {
        super();
        TrustManagerFactory factory = null;
        try
        {
            factory = TrustManagerFactory.getInstance("SunX509");
        }
        catch (NoSuchAlgorithmException nsae)
        {
            // Fallback attempt - try for an IbmX509 factory in case we're running in WAS with no Sun providers registered.
            try
            {
                factory = TrustManagerFactory.getInstance("IbmX509");
            }
            catch (NoSuchAlgorithmException nsae2)
            {
                throw new NoSuchAlgorithmException("Neither SunX509 nor IbmX509 trust manager supported.");
            }
        }

This code is part of latest BlazeDS distribution, so anyone facing above problem make sure that you upgrade the BlazeDS project to latest version. Hope this helps!

Flex datagrid is nice option to display data in tabular format and with built-in features like sort, rearrange column position and customize each columns with renderers/editors, it makes developers life easy to built user friendly application in quick time.  But most of the time, those who have coded in Flex, must have noticed that the datagrid just doesnt work properly when row information is updated. Consider following scenario.

1. Datagrid uses ItemEditor to update Collection bound as dataprovider.
2. A change in value of one of the column, involves updates to values displayed in other columns.

In 2nd step, user may change value in one of the column, which will internally result in change in value displayed in other columns. One can easily achieve that using itemEditEnd event but most of the time the updates are not reflected. Consider following code

Above code just binds one ArrayCollection to datagrid and editable values are displayed in textboxes. The basic requirement is that whenever user enters “Gross” and “Commission %”, the “Commission” and “Net” column should be updated. The logic to achieve this is defined in following function

private function calculateCommission(evt:AdvancedDataGridEvent):void
{
	if(evt.reason == DataGridEventReason.CANCELLED)
		return;
	var dtIndex:int = evt.currentTarget.selectedIndex;
	var dtField:String = evt.dataField;

	var gross:*, commPer:*, comm:*, net:*;
	var dataGross:* = evt.itemRenderer.data.gross;
	var dataCommPer:* = evt.itemRenderer.data.commPer;
	var dataComm:* = evt.itemRenderer.data.comm;
	var dataNet:* = evt.itemRenderer.data.net;
	switch(dtField)
	{
		case "gross":
			trace("gross column edited.");
			gross = evt.currentTarget.itemEditorInstance.text;
			if( (dataCommPer != null) && (dataCommPer!="") )
			{
				comm = (gross * dataCommPer) / 100;
				net = gross - comm;
			}else if( (dataComm != null) && (dataComm!=""))
			{
				commPer = (dataComm * 100) / gross;
				net = gross - dataComm;
			}else{
				net = gross;
			}
			break;
		case "commPer":
			trace("comm % column edited.");
			commPer = evt.currentTarget.itemEditorInstance.text;
			if( (dataGross != null) && (dataGross!="") )
			{
				comm = dataGross * (commPer / 100);
				net = dataGross - comm;
			}
			break;
		case "comm":
			trace("comm column edited.");
			comm = evt.currentTarget.itemEditorInstance.text;
			if( (dataGross != null) && (dataGross!="") )
			{
				commPer = (100 * comm) / dataGross;
				net = dataGross - comm;
			}
			break;
		case "net":
			trace("net column edited.");
			net = evt.currentTarget.itemEditorInstance.text;
			break;
		}

		var item:Object = evt.currentTarget.dataProvider.getItemAt(dtIndex);

		if(gross!=null)
			item.gross = gross;
		if(commPer!=null)
			item.commPer = commPer;
		if(comm!=null)
			item.comm = comm;
		if(net!=null)
			item.net = net;
		evt.currentTarget.dataProvider.itemUpdated(item);
		}

(Note that above code is not completed but used for illustration purpose). Above code updates values in respective properties of given item and invokes itemUpdated function on underlying ArrayCollection. If you run the application, you might notice that the application behaves unexpectadly. Sometimes the values are updated and sometimes it wont update value. To resolve this issue, comment “itemUpdated” function call and add following code.

var colEvent:CollectionEvent = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE,
true,false, CollectionEventKind.UPDATE);
colEvent.items = [item];
colEvent.location =  dtIndex;
(evt.currentTarget.dataProvider as ArrayCollection).dispatchEvent(colEvent);

You will now notice that everytime you update the column values, the changes are reflected properly. Above code will work in all scenarios, except one. To simulate that issue, perform following steps

1. Enter some values in all the rows.
2. Click on textbox displayed for “Commission” column of 1st row.
3. Without changing any value, now select “Gross” column textbox of 2nd row with left button of mouse.
4. Change the value displayed in “Gross” textbox of 2nd row and tab out. You will notice that tab will focus on 1st row rather than moving to next textbox.

The reason behind such unexpected behavior is that when user directly selects the value in any of the editable column, the datagrid controls is not able to track the event and hence the itemEditedPosition property is not set.
To make above code work, you should modify the itemRenderer attribute in above code and create one mxml renderer component. Refer to following code.

I would name this file as “AmountInput.mxml” and change itemRenderer Attribute of the datagridcolumn to point this new component.
Build the project and run it. Now you would notice that the data updations are reflected properly.

Hope this helps !

Updated : Thought of putting source code for this example, to download the source code just click here. I am using Flex SDK 3.4 with target flash player version as 10.0.0.

I remember almost 5-6 years back when I started learning many programming languages, .Net (1.1) was one of my favourite framework and C# was the language of choice. The event based programming model, readymade suite of components with ASP.Net was definitely an interesting way to develop web applications. The ease of development and powerful Visual Studio IDE had really impressed me. In fact, I was quite comfortable with Visual Studio much before .Net came into market, the reason was – Visual Basic. No one could have ever imagined that the language like Basic can become so powerful and provide so many functionalities.

But as the time passed and I spent more and more time with Java, I started to loose touch with .Net. Few weeks back when I came to know about release of Microsoft .Net framework 4.0 & Visual Studio 2010, suddenly everything just flashed in my brain. I have been hearing buzzwords like WCF, WPF from a long time, but due to constant focus on Java I simply had no clue what was going on in .Net world.

The curiousity has just began again and I felt need to get back to the language and framework, I liked most.

Almost 7 years back when, I joined first organisation, inspite the fact of knowing languages like Visual Basic 6.0, ASP, Java 1.2, PHP 4, C, Shell Script, Oracle PL/SQL, MySQL [and little bit .Net] etc., I started working on HTML and JavaScript. The goal was to understand how online shopping sitess actually work [and the most important getting breakthrough in IT industry ]. The things were quite simple as apart from Web page designing there was no much responsibility and there was less headache in terms of banging head on fixing bugs. After few days, there was one of the Perl programmer working on some implementation got stuck in one of the implementation and was not able to resolve it. Being curious to know, what was the problem, I just thought of having a look at the Perl code. Well having a little bit idea of shell scripting and knowledge of PHP proved bit of help here. The Perl code look somewhat familiar to me and the problem (generation of some JavaScript logic using Perl Script) was resolved within few minutes.

One day I came across a situation where I saw a solution which was initially thought to be implemented in Java, failed miserably due to performance issues. The similar requirement was then implemented using .Net framework and it worked pretty well. Well the fact was, the decision of implementing the requirement using Java was incorrect. The language was not suitable for the kind of native integration and had serious performance bottlnecks.

The point, I want to bring here is that we see so called “Technical Specialist” & “Architects” who always focus on one vertical and try to be specialist in one technology - ignore the features offerred by other languages/platforms. Though Its not possible to be a master of each and every platform, there is need for every technical guy to gain knowledge of other platforms and urge to find out options available in competing platforms. Well sometimes it is purely managerial decision to choose the technology, the efforts need to be put by people (quoted above) by listing alternatives with evidences. The other option is that, at organisation level a group of such experts (obviously with different flavors of technology) should be created and high solutions/design review should be done by such team.

For a long time, the customers were concerned for getting business done, are now also look into the platform on which the application/product is running. The changing attitude of customers demands serious need of  Techies with the ability to understand multiple technology and its application for a business need. Sadly most of the people, I came across are sticked to one platform and trying to be specialist/expert :( not even realising the threat it might create.

I was looking out for a utility/library which can be used to generate Java Source code. Initially I thought of using source code templates and generate Java Files from it. But fortunately I came across an interesting library CodeModel.

This library is used by most of the popular code generators including JAXB. The library provides set of API classes which can be used to generate Java Source code (supports Java 5 generics, annotations etc.). The only downside of this library is that, it is not well documented. Worst part is, there are no tutorials available. So If you want to find out more details about how this library works, you better fold your sleeves and start writing some code which uses API. Good Luck.

I was recently trying to fix one error and after installing patch 31 on IBM websphere 6.1.0.25, I came across a weird problem – My application was trying to connect to database using DBCP common pool and it suddenly stopped working after applying patch. The error message logged in file was “Network adapter could not establish connection”.

It was quite unexpected to see this error as I could easily able to connect database from other machine. So I thought of writing simple JDBC code and tried to connect to the database from Websphere machine. To my surprise, this code was working as expected and could able to connect the database. It was quite frustrating as we couldn’t able to figure out why DBCP pool stopped working after installing patch 31. After googling on this problem, I found that using ojdcb5.jar would reveal more details about error and it worked for me. This time, rather than just saying “Network adapter…”, it also logged an error message as “Address already in use : NET_Bind”. Well this was obviously more confusing than the earlier one, as it wasn’t quite clear what was the cause of the error. The error continued to show up after restarting Websphere and even after restarting whole machine.

After reading patch 31 readme notes, I found that it is also necessary to update IBM JVM fix compatible for patch 31.  The JVM patch is not bundled with Websphere patch and should be applied separately.

Yippee, after installing the JVM patch the “Address Already in use…” error got whooshh… Hence I would like to advice Websphere users to carefully go through the readme notes of any patch and make sure that dependent patches are applied correctly OR else you might get caught in trap of errors.

Last week, I was trying to deploy CXF 2.X webservice application on Websphere 6.1.0.X. Everything worked well and no error at the time of deployment. But while invoking webservices, we were getting an error

java.lang.NoClassDefFoundError: com.sun.org.apache.xerces.internal.dom.DocumentImpl

After googling, we found that this class is integral to JDK 1.5 and ships along with it. We were bit confused as the application was working fine on development machines with no errors. After googling more, the same problem was reported on most of the forums by Websphere users.

Well there was definitely difference between the development environment and testing environment. Developers were using Sun JDK 1.5.0_16 + Jboss 4.2.2 GA, while the testing environment had IBM JDK 1.5 SR 2 + IBM Websphere 6.1.0.25.

The class mentioned above is already available in rt.jar of SUN JRE but it is missing from IBM JDK (what a X@#$). The solution to this problem is to download JAXP library from https://jaxp.dev.java.net/. It is downloadable as .class file. To get the jar files from the class, you need to execute the .class file using “java” command. It will extract JAR files, copy xercesImpl.jar file to WEB-INF/lib folder of the application & restart the server.

If the application still gives the same error, make sure the classloader policy is changed to load application classes first.

Finally, completed Sun Certified Enterprise Architect certification.

Scalability, performance etc are all required to good build softwares. Before starting development, majority of the firms do come up with well designed Software Architecture and address customer needs in efficient way. Selecting right technology, infrastructure and placing frameworks at right place are all required to build robust applications.
While we can see there are new frameworks/languages coming in the market with the capability to address modern day problems, the customers are also concertrating more on how the application can help them to quickly address business problems and tap market opportunities.

Once the application is built and it goes in to the production mode, the customer starts demanding new changes into the application to meet certain requirements. The changes could range from adding new field on screen to building new report or developing webservices, defining workflows etc. Finally all this comes back to the development company as a Change Request and developers start modifying existing code to meet the requirements. This is what a typical development/maintainance cycle that we normally experience at the work.
While most of the designers/architects/developers feel that it is the technology which matters alot while developing application, the end users/customers are interested in how well the requirements are implemented and the capability of system to accommodate new changes. As said earlier the changes could be simple like adding field or could be complex like building new webservice, today’s customers don’t just prefer it to be developed in less time but demand to have their own control over such development.
Few days back while attending one of the pre-sales demo, I observed that the prospect was continuosly emphasizing on how application can be managed by its own IT staff and how easy is to modify the application screen to meet the requirements. The simple reason for asking such reason was, there is a product in the market (developed almost 8-9 years back) which has integrated environment giving an end user the control to add/modify screens, build workflows, build webservices, maintain source repository, build test cases etc without writing a single line of code. (Sorry, I can’t mention the name of the product and its not an ERP system). It was the first time I heard of such software which allows to do everything from its IDE without a need of experties in any specific computer language. The business analysts can easily modify the application as per the business needs without having dependency on the developers to make changes in code. The biggest advantage of such application is the time spent in accomodating new requirement by customer IT team VERSUS time spent in following entire software life cycle, if implemented by development company. Definitely such software relieves customer from being dependent on a Software vendor. Customers don’t have to fallback on software vendors for majority of its requirement, saving lot of money that could be otherwise invested in strengthening its market position.
While I am pretty much impressed with this software, I could see lot of designers/architects are still thinking about making use of new frameworks/languages to build good software and not even aware of such software that do exist and slowly becoming threat for majority of Software companies. How many of them have really thought about/developed such a design giving full control to the customer?