Upgrading Clients
In cases where the GUI is loosely coupled to the other legacy tiers
you can use an applet or a small application to replace the GUI.
Clients can communicate with the other tiers using:
- TCP sockets
- COM/CORBA Objects
- Screen Scrapers
- Object Mapping tools
- Off-board server
TCP sockets.
Applets can be signed and trusted if necessary to access TCP resources.
COM/CORBA objects
Clients can communicate with COM and CORBA objects using bridge
or Java IDL.
Screen Scrapers
Screen scrapers may be used to integrate applet (or other) interface
with an existing system. They are particularly useful when the client
interface is tightly coupled to the other tiers of the system.
A screen scraper is an application that translates an existing
client interface into a set of objects. Screen scrapers usually
function as a terminal emulator on one end and an object interface
on the other. The screen scraper is configured to read data from
terminal fields of the legacy interface and make them available
via objects.
Screen scrapers have the following advantages:
- Provides a low-level object-based interface to the legacy app.
- Allows you to build a new GUI over the existing client interface.
Disadvantages of screen scrapers:
- Any changes to the legacy interface can break the new GUI.
- Prone to causing errors in the new GUI because of unexpected
outputs from the legacy interface.
- Prone to causing the new GUI to “freeze” when the
legacy interface is expecting input that the screen scraper in
unaware of.
Object Mapping Tools
Object mapping tools can be used if you choose to ignore the existing
legacy interface and access the underlying tiers directly. These
tools are used to create proxy objects that access legacy system
functions and make them available in an object-oriented form.
Object mapping tools are usually more effective than screen scrappers
because they are not dependent on the format generated by the existing
legacy interface.
Off-board server
An off-board server is a server that executes as a proxy for a
legacy system. It communicates with the legacy system using the
custom protocols supported by the legacy system. It communicates
with external applications using industry-standard protocols.
Upgrading Business Logic
Java Servlets
Java servlets provide a capability to make existing applications
available via an intranet or the Internet. Clients (browsers and/or
applets) access servlets via HTTP or HTTPS. The servlets take the
requests and communicate with the legacy system.
Enterprise Java Beans
EJBs provide a component-based approach to upgrading legacy applications.
CORBA/COM
Java’s support for CORBA enables CORBA objects to be accessed
from Java and Java objects to be accessed as CORBA objects.
Microsoft’s JVM provides (or used to provide) a bridge between
Java and COM objects.
Java Native Interface (JNI)
JNI may be used to write custom code to interface new business
logic with an existing legacy system.
Upgrading the Data Storage Tier
JDBC may be used to access relational databases in a legacy system.
In many cases the legacy database will not support a pure JDBC
driver. If the database provides ODBC support the JDBC-ODBC bridge
can be used.
If the existing legacy database is hierarchical or flat-file then
it may be able to be imported into an RDBMS.
Securing Legacy System Components
Retrofitting a system with security is generally more expensive
and less productive the redesigning and redeveloping the system
to operate in a secure manner. However, budget constraints may prevent
this.
Legacy systems may be isolated from threats by placing them behind
a firewall.
Access control to legacy systems can be controlled by requiring
users and external applicationsto authenticate themselves with the
firewall before they can access the legacy system. Auditing features
of the legacy system should be used to determine who is accessing
the legacy system and when.
A Virtual Private Network (VPN) may be used to secure all communications
with a legacy system.
Data-level Integration
From the point of view of a Java application, this type of integration
focuses on the access of legacy databases or files by either session
beans or entity beans. It also includes access to newly developed
data feeds, produced by the legacy system, for the specific purpose
of data access. XML is often used for this integration technique
because XML is a platform-independent approach for sharing data.
The advantages of data-level integration are that it is fairly straightforward
and quick to implement. The disadvantages include increased data
coupling between applications, thereby increasing your maintenance
burden; the inability to access important behavior such as data
validation and critical business rules; and the need to write significant
data cleansing/formatting code for poorly designed data.
Application-interface integration
With this approach, you leverage the application programming interfaces
(APIs) exposed by your applications to access both the data and
the functionality encapsulated by legacy systems. The advantage
of application-interface integration is that this approach is fairly
standard within the industry; many packages such as SAP and PeopleSoft
include C-APIs that you can access via Java Native Interface (JNI)
code. The main disadvantages are that software developed within
your organization rarely has a defined API; the APIs may be limited
in scope and may not offer the behavior that you need (or in a manner
that you need it); and APIs are often function-oriented in nature
and not object-oriented.
Method-level integration
With this approach, business logic is shared as a collection of
shared methods, or operations that your software can invoke. For
example, common operations to update customer data, to validate
a credit card transaction, or to deposit money into a bank account
may be made available in a common repository or reusable framework
that all applications have access to. The advantages of method-level
integration are that it often provides fine-grained access to common
business functions; a wide range of applications (including both
Java and non-Java) can access the operations; and invoking the methods
is straightforward. The disadvantage is that the fine-grained nature
of the common methods can make it difficult to support transactions
or to support common technical services, such as security access
control, without significant scaffolding in each method.
User interface-level integration
This technique focuses on accessing existing applications through
their user interfaces, a process called screen scraping, in which
user keystrokes are simulated to implement the interaction with
the legacy software. Screen scraping is a common technique used
by Web-based aggregator sites, for example Vertical One, to present
personalized views of financial or other types of information. The
advantage is that this is a time-tested and common approach for
legacy integration, one that is taken by many user interface testing
tools such as Mercury Interactive's WinRunner or SQA Suite from
Rational Corporation. The main disadvantage is that this approach
can be slow: you need to wait for the legacy application to render
the screen that you are scraping, and any changes to the legacy
user interface necessitate changes to your integration code.
|