Introduction

This article is part of a series of IBM ® VisualAge® for Java™ CCF to WebSphere® Studio J2C migration articles that describe the typical activities for migrating CCF CICS® ECI, IMS™, or WebSphere MQ into J2C applications. This series includes the following articles:

• CCF to J2C migration: Part 1: CCF application limitations on WebSphere Studio Application Server V5
• CCF to J2C migration: Part 3: Migrating VisualAge for Java CCF CICS-ECI applications into WebSphere Studio J2C CICS-ECI applications
• CCF to J2C migration: Part 4: Migrating VisualAge for Java CCF IMS applications into WebSphere Studio J2C IMS applications
• CCF to J2C migration: Part 5: Migrating of VisualAge for Java CCF MQ applications into WebSphere Studio J2C JMS applications

Back to top

Overview

VisualAge for Java uses the Common Connector Framework (CCF) to simplify the creation and maintenance of Java applications that access host Enterprise Information Systems (EIS's). These EIS resources are typically Customer Information Control System (CICS®) transactions, Information Management System (IMS) transactions, or WebSphere MQ message queues. The VisualAge for Java Enterprise Access Builder (EAB) feature supports this CCF framework by providing tools to create CCF connector objects (Java command and record classes), and applications that use these CCF connector objects.

As the value of the CCF framework became recognized and accepted, IBM submitted it for consideration as an industry standard. After review and modification, it became J2EE Connector Architecture (J2C). While J2C is similar to its predecessor CCF, there are significant differences between the two and migration is not trivial.

Given these differences, WebSphere Studio Application Developer Integration Edition (hereafter referred to as Application Developer) has a new set of tools, optimized to create and maintain J2C objects and applications. It is, of course, desirable to be able to migrate existing VisualAge for Java CCF applications into Application DeveloperJ2C applications (whenever there are J2C equivalents). This paper describes migration of EAB tool-generated connector objects, and migration of developer-written applications using those objects.

Back to top

CCF to J2C migration steps

Below is a summary of the major steps involved in migrating a CCF application into a J2C application:

1. Setup:
   • Ensure that VisualAge for Java V3.5.3 or 4.0 is available with the existing CCF applications.
   • Ensure that WebSphere Studio Application Developer Integration Edition V5.0.1 (or later) is available with the required resource adapters, and with the CICS/IMS CMA and the current fixes installed:
     1. V5.0.1 (which is V5.0 plus PTF-001)
     2. Plus Fix Pack 001> (containing Interim Fixes 001 to 006)
     3. Plus WSADIE V5.0.1 Interim Fix Run Time (for WebSphere Application Server V5.0)
     4. Plus Interim Fix 007 and Interim Fix 008
2. VisualAge for Java export:
   • Group CICS/IMS artifacts together (same short/long name generation style, same server name/location, same mirror transaction name).
   • Export grouped CCF CICS or IMS artifacts (only classes, not source) as Java JAR files.
   • Export CCF MQ artifacts (only source, not classes) as Java JAR files.
   • Export each CCF application (only source, not classes) as a Java JAR file.
3. Studio import and migration of generated CCF artifacts:
   • Import a CCF CICS or IMS artifact JAR file (keeping it as a JAR file) and migrate it through the CMA into new J2C objects (source plus classes), or:
   • Import a CCF MQ artifact JAR file (as a normal Java project) and manually migrate it using the CCF-to-J2C coding guidelines.
4. Studio import and migration of customer CCF applications:
   • Import each CCF application JAR file (as a normal Java or Web project) and manually migrate it using the CCF-to-J2C coding guidelines.
   • Manually change the applications to accommodate new JDK levels, new Server APIs, and so on.
   • Manually change any associated Web code to accommodate new JSP or HTML levels, new server APIs, and so on.
5. Deploy and test:
   • Use Studio WebSphere Test Environment (WTE) and/or remote WebSphere Application Server instances.

Back to top

VisualAge for Java setup of EAB CCF connectors and samples

This article assumes that you have VisualAge for Java V3.5.3 or V4.0, with appropriate EAB CCF connectors installed, because migrating such previously developed CCF applications is the purpose of this article series. If you did not install the matching CCF connector samples, you should install and migrate them in order to develop familiarity and experience with the migration process for your application connector types.

This article series does include instructions for using the VisualAge for Java CCF tools or the Application Developer J2C tools. For more information about either toolset, see the online help and sample programs for the related product.

Back to top

Studio setup of J2C resource adapters and samples

J2C defines the concept of a run-time Resource Adapter (RA), which is analogous to CCF connectors. The RA is packaged in a Resource Adapter Archive (RAR file), which contains a deployment descriptor, help files, and the Java interface, implementation, and helper classes of that resource adapter. Resource adapters are installed into an application server, such as WebSphere Application Server, which supports the J2C specification for transaction management, security, and connection management.

In order to develop J2C applications in Application Developer, you must install appropriate Resource Adapters. For example, to develop a CICS ECI application, you must install the CICS ECI RA. The easiest way to do this is to follow one of the Studio samples such as the CICS ECI Sample (select Help => Help Contents => WebSphere Studio => Business Integration => Samples => CICS Samples). Using this sample will ensure that the RA is properly installed, and gives you a reference sample and some hands-on experience with the Application Developer tools.

Back to top

VisualAge for Java export of CCF artifacts (CCF-generated objects)

The Java source for developer-written CCF applications is exported from VisualAge as Java Archive (JAR) files, and then imported into Studio Java projects, the same as for any other Java program. Such applications will still require matching CCF-generated connector objects in order to work. If necessary, the default approach is to manually use the Application Developer tools to regenerate all of the new J2C objects, including all of their settings and data, and then figure out what corresponding manual application changes are required to make everything compile and execute. Therefore, a key migration question is how to export the CCF artifacts and then import them and maintain them using Application Developer. The answer depends on what type of CCF connector is involved and what type of equivalent J2C connector (if any) is available in Application Developer.

Back to top

Not supported: Studio source import and rebuild of CCF artifacts

One unsupported approach is to install the CCF connectors in Application Developer and WebSphere Application Server (see the previous limitations article, and note that the actual CCF connectors require run-time licenses for installation and use in WebSphere Application Server). Then export the EAB-generated CCF artifacts (Java source for generated commands and records) into Application Developer. You can then use the default Application Developer Java editor to manually edit them, since they are just Java source files, but Application Developer cannot regenerate any CCF objects.

Most CCF applications and CCF artifacts rebuild properly in Application Developer and run successfully on WebSphere Application Server, but this procedure is not supported and not tested because of differences in the Java compiler level, other updated libraries, and system API changes.

Back to top

CCF Migration Assistant (CMA) for CCF artifacts, and CCF application migration coding guidelines

In some cases, you can read the settings and data in CCF Command classes and then programmatically invoke the Application Developer J2C tools to create equivalent J2C "command" service proxy classes. Similarly, you can read CCF record classes and use the settings and data programmatically to invoke the Application Developer J2C tools to create equivalent format handler and data bean helper classes.

CMA limitations

The CMA program goes a good job of migrating many CCF artifacts into new J2C objects. However, there are certain limitations and restrictions, and these are described in the detailed CICS-ECI and IMS migration articles.

Obtaining the CCF CMA program

The CCF CMA program can migrate many CCF-generated CICS-ECI or IMS connector objects (CCF commands and CCF records) into the most application-compatible type of J2C connector objects ("Command" service proxies, format handlers and data beans). This CMA program is not part of Application Developer and is not supported. It seems to work well for the situations described (CICS-ECI and IMS). For details about the CMA program, see the CICS-ECI and IMS migration articles.

The CMA program is not attached to this article for download, because we want to know who is using it so we can send out updates as needed. To request the CMA program, sent a note to searle@ca.ibm.com.

For information about purchasing formal CCF-to-J2C migration assistance, including installation of and training on the CMA program, see Migration Assistance Services below.

CCF application migration coding guidelines

Each of the detailed migration articles summarized below includes coding guidelines describing the manual application changes typically required to use CMA migrated artifacts, and/or to manually migrate other CCF applications. The coding guidelines in each of these articles are based on experience to date, and will be updated if new information becomes available.

Back to top

Migration of CICS-ECI or IMS or MQ applications

CMA CICS-ECI migration and manual application migration

The CICS-ECI article describes how you can use the CMA program to migrate CCF-generated CICS-ECI connector objects (commands and records) into equivalent J2C objects ("command" service proxies, format handlers, and data bean helpers). It also describes the coding changes typically needed to manually migrate applications that use these objects.

CMA IMS migration and manual application migration

The IMS article describes how the CMA program can be used to migrate many CCF generated IMS connector objects (Commands and Records) into equivalent J2C objects ("Command" Service Proxies, Format Handlers, and Data Bean helpers). It also describes the currently known coding changes typically needed to manually migrate applications that use these objects.

CCF IMS artifact migration is very similar to CCF CICS-ECI artifact migration, with a few minor changes.

Manual message queue (MQ) to Java Message Service (JMS) application migration

The MQ article describes the typical manual changes required to change a CCF MQ connector application into a JMS application. There is no J2C MQ connector, because the CCF MQ connector has been replaced with the industry-standard JMS. Although J2C service proxies are not used, the article also describes how to use the Application Developer tools to generate format handlers and data beans, and also how to access and manipulate the data byte buffers in these helper classes.

Back to top

Manual upgrades to new JDK and server API levels

Important: All of the previously mentioned CCF migration activity involves only the connector migration specifics. It does not address any of the normal lifecycle application maintenance needed because of new JDK API levels, new Server API levels, new Web J2EE JSP or HTML levels, and so on.

Back to top

Migration assistance services

IBM WebSphere Services has a range of migration assistance that customers can purchase:

1. On-site training or assistance for WebSphere Application Server V3.5 => V4 => V5 application migration
2. On-site assessment of CCF application migration, description of work, and scope of effort
3. Installation and familiarization with the CCF Migration Assistant (CMA) program
4. Pilot migration of small applications or application components
5. Optional migration of larger applications

For further information, contact:

• In North or South America: Mitch Johnson via e-mail at mitchj@us.ibm.com or via phone at 1-919-254-0065
• In Europe or the Middle East: Richard Johnson via e-mail at richardj@uk.ibm.com or via phone at 44-1962-817714
• In Asia Pacific: Rick Jones via e-mail at at rick.jones@au1.ibm.com or via phone at 61-2-9478-8219

Back to top

Conclusion

WebSphere Studio Application Developer Integration Edition has a completely new set of tools optimized to create and maintain J2C objects and applications. It is desirable to migrate existing VisualAge for Java CCF applications into WebSphere Studio J2C applications whenever there are J2C equivalents. This article has covered two main topics: migrating EAB tool-generated connector objects, and migrating developer-written applications using those objects.

About the authors

Ellen Matheson McKay is an Information Developer for IBM Canada Ltd. She writes online help and publications for WebSphere Studio Application Developer.

Barry Searle is the Migration Team Leader for WebSphere Studio Application Developer. He is a Professional Engineer who has worked at the IBM Canada Lab for over ten years on various application development tools. Prior to that he had many years of industry experience developing command and control systems and leading communications development projects.

Comments (Undergoing maintenance)

Back to top

Trademarks  |  My developerWorks terms and conditions

Table of contents

• Introduction
• Overview
• CCF to J2C migration steps
• VisualAge for Java setup of EAB CCF connectors and samples
• Studio setup of J2C resource adapters and samples
• VisualAge for Java export of CCF artifacts (CCF-generated objects)
• Not supported: Studio source import and rebuild of CCF artifacts
• CCF Migration Assistant (CMA) for CCF artifacts, and CCF application migration coding guidelines
• Migration of CICS-ECI or IMS or MQ applications
• Manual upgrades to new JDK and server API levels
• Migration assistance services
• Conclusion
• About the authors
• Comments

Next steps from IBM

Rational Application Developer features provide the comprehensive Integrated Development Environment (IDE) used to develop J2EE applications requiring Servlets and JavaServer Pages (JSPs).

---

• Try: Try the free Rational Application Developer, which helps developers quickly design, develop, test, analyze, and deploy high-quality Java, Javaserver pages, and J2EE applications.
• Article: Learn how you can deliver accurate, higher-quality J2EE apps with Rational Application Developer, open source JUnit and JUnitEE test frameworks.
• Tutorial: Build a Facebook application using PHP, the Spring framework, and J2EE.
• Buy: Rational Application Developer

My developerWorks community

Dig deeper into WebSphere on developerWorks

Rate a product. Write a review.

Write a review for Rational products today!

Special offers