Hi
I first have to thank you John and Amanda for some excellent information on Legacy Connectivity
I have combined your notes on Legacy Connectivity and also obtained some information about it from sun site.
Is all this information about Legacy Connectivity enough for the Certification, or do I still have to do some more searching.
--------------------------------------------------------
Legacy Connectivity Overview (Amanda)
It can be split into two main parts
1. On one hand you have Legacy API's that
Java has built in support for e.g. Java IDL and
JDBC (including the JDBC-ODBC bridge) and you can include others such as JMS which supports connectivity to existing messaging systems. Java Connector Architecture as in
J2EE 1.3 beta.
2. And on the other you have Legacy API's, systems and protocols that Java doesn't have built in support for e.g. Screen Scrapers, Objects Mappers (Object Wrappers), Protocol Bridges and middle ware products that support Java on one side and a Legacy API on the other. You can also write your own Java code that connects to legacy applications/systems where there is no off the shelf product available. You may do these using sockets to a networked application or you may do this using JNI to a local application that doesn't have network connectivity.
There are an infinite number of legacy connectivity scenarios, many of which have already been addressed, but also many of which have not (or have been in one or two places but have never been documented). It's the job of the architect to be aware of what is available in terms of tools and to use those tools appropriately.
Legacy Connectivity Design Issues (John)
Distinguish appropriate from inappropriate techniques for providing access to a legacy system from Java code given an outline description of that legacy system.
Upgrading Client-Tier GUIs
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.
Applets can communicate with the other tiers via TCP sockets. The applet can be signed and trusted, if necessary to access resources.
Applets can also communicate with COM and CORBA objects (using bridge or Java IDL).
Screen Scrapers
A Screen Scraper is an application that translates an existing client interface into a set of objects.
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 and also used if the legacy system does not have a published interface or the documentation has been lost.
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.
Advantages
1. Provides a low-level object-based interface to the legacy app.
2. Allows you to build a new GUI over the existing client interface.
3. It can be implemented without any disruption to existing legacy applications, and also the training requirements for the new system should be minimal
Disadvantages
1. Any changes to the legacy interface can break the new GUI.
2. Prone to causing errors in the new GUI because of unexpected outputs from the legacy interface.
3. Prone to causing the new GUI to "freeze" when the legacy interface is expecting input that the screen scraper in unaware of.
4. It is generally pretty slow, and the application cannot be modified to allow additional functionality. All you can really do is put a new interface on an old application using screen scraping
Object Mapping Tools (Object Wrappers)
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.
You can wrap up an existing non object-oriented system and then use CORBA to communicate), or alternatively to use any published interface to the legacy system (for example, the legacy system might support TCP sockets)
Object mapping tools is usually more effective than screen scrappers because they are not dependent on the format generated by the existing legacy interface.
Advantages
1. Object based access to the Legacy System
Disadvantages
2. You have to write the wrapper code your self.
Upgrading Application Business Logic
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.
EJBs provide a component-based approach to upgrading legacy applications.
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.
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 then 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 applications to 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 VPN may be used to secure all communications with a legacy system.
Four Classes of Legacy Extension (java.sun.com)
The GartnerGroup has identified the following four classes of legacy extension functionality.
� Graphical User Interface (GUI) extension. GUIs may include middleware-only solutions that interpret screen definition languages for the 3270 mainframe, 5250 AS400, VT100 DEC and HTTP formats, and can pass either an interpreted screen and/or a standard data stream. Some GUIs add windows to the resulting screens. Others add languages that allow for new workflows by combining and/or dissecting screens that can be mass-customized around specific events, and/or clients.
� Transactions Reuse is a method by which whole transactions that produce data streams, messages and/or changes can be reused. Transactions can sometimes be mapped to SQL, so that the transaction can be used as a data source. Vendors are usually emulator, transaction monitor, message broker, and/or request broker. They generally comprise functionality that includes simple forms of GUI extension as well.
� Process Understanding and Recovery is performed by vendors that specialize in the understanding of multiple computing languages through language parsers. They offer help with graphic representation and benchmarking measurement in areas such as complexity and data name rationalization.
� Data Understanding and Recovery technologies allow for the understanding of implied data models in existing physical files. These physical models can be turned into logical models for further enhancement or extension and/or into different file definition languages.
Graphical User Interface technology currently leads the market, with Transaction Reuse second. Often, the two are used in tandem.
The Benefits of Legacy Extension
The cheapest application is the application you don't have to write One way to unshackle from legacy applications is to rebuild applications on a new platform, with a different language, different communications, and different connectivity protocols. The problem is that, unless the application is small, and resources are plentiful, the time and expense required in rebuilding from scratch is likely to be prohibitive.
Thus the benefits of extending conventional host-based applications from the prison of proprietary desktops and networks include:
� Big financial savings by cutting network and terminal costs.
� Bonus return on the original investment in legacy systems.
� Opportunities for electronic commerce using legacy databases. Through "Weblications," businesses can create a presence on the Web and outsource functions like order-taking and servicing to end clients.
� More satisfied users who get an attractive graphical interface.
� More integrated and efficient functionality.
-----------------------------------------------------------------
Thanx
Vivek
