284

Guidelines for Integration

connector, but (with the help of other J2EE application server services) it may also

create a Web services layer.

Generally, there are two scenarios involving the integration of custom sys 

tems. In one case, two EIS systems need to interact with each other. The connector

approach works well with this type of scenario: You merely write Java classes

implementing the business logic for one EIS and use a connector to communicate

to the other EIS system. In the second scenario, you intend to have several appli 

cations use a custom EIS. For this case, it is better to plug the custom EIS into the

application server and expose the EIS's reusable business logic through the appli 

cation server. You can expose the logic either by using enterprise beans with JMS

or by using a Web services approach. If the situation warrants it, you can use both

enterprise beans with JMS and a Web services approach together. 

6.5.2 Using Screen Scraping for Integration

There are times when you may want to integrate an EIS that has no programming

interface. Often, this happens with legacy mainframe applications. In these cases,

you can resort to screen scraping to create a programming interface. With screen

scraping, you write an adapter layer that acts as an end user entering data into the

mainframe application, and this adapter layer serves as the programming interface.

You then write a connector that uses this programming interface to accomplish its

integration actions. 

When resorting to screen scraping, be sure to keep in mind the limitations of

the legacy system. Although you can integrate a new application to a legacy

system, the original system has limitations that may make it unable to handle the

new functionality. For example, suppose you used screen scraping to integrate a

front end application with a mainframe application designed to be interactive. The

front end application, since it has no human constraints, can suddenly pump in a

high volume of requests to the mainframe application, which may not have been

designed to handle such a load. It is hard to detect a problem such as this until

runtime, when the system is suddenly overwhelmed with a high volume of

requests. By this point in the development cycle, it may be quite expensive to fix

the application.