Introduction to the ADK

 

This guide is the "how to" guide for using the WebLogic Integration Adapter Development Kit (ADK). It will show you how to develop, test, and deploy event and service adapters and the design-time user interface.

This section provides information on the following subjects:

• What is the ADK?

• What are Adapters?

• The Design-Time GUI

• Before You Begin

 

---

Section Objectives

This section serves as an overview to using the ADK to develop event and service adapters and a design-time GUI. You will learn:

• What adapters are and how they are used.

• Prerequisites you must meet before beginning adapter development.

• Terminology associated with adapter development.

 

---

What is the ADK?

The ADK is the tool set for implementing the event and service protocol of BEA WebLogic Integration; that is, it is a collection of frameworks that support the development, testing, packaging, and distribution of resource adapters for WebLogic Integration. Specifically, the ADK is comprised of the following four frameworks:

• Design-time

• Run-time

• Logging

• Packaging

Requirements for Adapter Development

The ADK addresses three requirements for adapter development:

• Structure: A prominent theme in any integrated development and debugging environment (IDDE) is development project organization. You want a well structured development environment so you can immediately begin coding the adapter. You do not want to spend time designing and organizing a build process. The ADK provides an organized development environment, build process, intuitive class names and class hierarchy, and test methodology. Since the ADK encompasses so many advanced technologies, an incremental development process (code a little, test a little) is the key to success. The ADK test process allows the developer to make a simple change and test it immediately.

• Minimal Exposure to Peripheral Implementation Details: Peripheral implementation details are sections of code that are needed to support a robust software program, but are not directly related to the kernel of the program. Moreover, peripheral implementation details are sections of code that are needed to support the framework the software program runs in. For example, the J2EE Connector Architecture specification requires that the javax.resource.cci.InteractionSpec implementation class provide getter and setter methods that follow the JavaBeans design pattern. To support the JavaBeans design pattern, you need to support PropertyChangeListeners and VetoableChangeListeners in your implementation class. You do not want to have to study the JavaBeans specification to learn how to do this. Rather, you want to focus on implementing the enterprise information system (EIS)-specific details of the adapter. The ADK provides base a base implementation for a majority of the peripheral implementation details of an adapter.

• A Clear Road Map to Success: A key concept in adapter development is the exit criteria. The exit criteria answers the question: "How do I know I am done with an implementation?" In other words, you want a clear road map of what needs to be implemented to complete an adapter. The ADK provides a clear methodology for developing an adapter. The ADK methodology organizes your thoughts around a few key concepts: events, services, design time, and run time.

What the ADK Provides

The ADK provides:

• Run-time support for events and services.

• An API to integrate an adapter's user interface into the WebLogic Integration Application View Management Console.

  The added value provided by the ADK is that adapters can become an integral part of a single graphical console application that allows business users to construct integration solutions.

 

---

What are Adapters?

Resource adapters—referred to in this document as "adapters"—are software that connect one application to another when those applications are not originally designed to communicate with each other. For example, an order entry system built by one company requires an adapter to communicate with a customer information system built by another.

By using the ADK, you can create two types of adapters:

• Service adapters, which consume messages.

• Event adapters, which generate messages.

You can also use the ADK to create J2EE-compliant adapters that are not specific to Weblogic Integration but still comply with the J2EE Connector Architecture Specification.

Service Adapters

Service adapters receive an XML request document from a client and invoke a specific function in the underlying enterprise information system (EIS). They are consumers of messages and may or may not provide a response. There are two ways to invoke a service: asynchronous and synchronous. With an asynchronous service adapter, the client application issues a service request and then proceeds with its processing. The client application does not wait for the response. With a synchronous service adapter, the client waits for the response before proceeding with its processing. BEA WebLogic Integration supports both of these service adapter invocations, relieving you from having to provide this functionality.

Service adapters perform the following four functions:

• Receive service requests from an external client.

• Transform the XML request document into the EIS specific format. The request document conforms to the request XML schema for the service. The request XML schema is based on metadata in the EIS.

• Invoke the underlying function in the EIS and wait for its response.

• Transform the response from the EIS specific data format to an XML document that conforms to the response XML schema for the service. The response XML schema is based on metadata in the EIS.

As with events, the ADK implements the aspects of these four functions that are generic across all service adapters.

To learn how to develop a service adapter, see Developing a Service Adapter.

Event Adapters

Event adapters are designed to propagate information from an EIS into WebLogic Server. These types of adapters can be described as publishers of information.

There are two basic types of event adapters: in-process and out-of-process. In-process event adapters execute within the same process as the EIS. Out-of-process adapters execute in a separate process. In-process and out-of-process event adapters only differ in how they accomplish the data extraction process.

Event adapters running in a WebLogic Integration environment perform the following three functions:

• Respond to events deemed to be of interest to some external party that occur inside the running EIS and extract data about the event from the EIS into the adapter.

• Transform event data from the EIS specific format to an XML document that conforms to the XML schema for the event. The XML schema is based on metadata in the EIS.

• Propagate the event to an event context obtained from the application view.

The ADK implements the aspects of these three functions that are generic across all event adapters. Consequently, you can focus on the EIS specific aspects of their adapter. This concept is the same as the concept behind Enterprise Java Beans (EJB). With EJB, the container provides system-level services for EJB developers so they can focus on implementing business application logic.

To learn how to develop an event adapter, see Developing an Event Adapter..

J2EE-Compliant Adapters Not Specific to WebLogic Integration

These adapters do not contain WebLogic Integration specifics and can be plugged into any application server that supports the J2EE Connector Architecture specification. These adapters can be developed by making minor modifications to the procedures given for developing a service adapter. To learn how to develop an adapter that is not specific to WebLogic Integration, see Creating an Adapter Not Specific to WebLogic Integration.

 

---

The Design-Time GUI

Along with event and service adapters, the ADKs design-time framework provides the tools you will use to build the Web-based GUI that adapter users need to define, deploy, and test their application views (see The Application View below). Although each adapter has EIS-specific functionality, all adapters require a GUI for deploying application views. This framework minimizes the effort required to create and deploy these interfaces, primarily by using these two components:

• A Web application component that allows you to build an HTML-based GUI by using Java Server Pages (JSP). This component is augmented by tools such as the JSP templates and tag library and the JavaScript library.

• A deployment helper component, called AbstractDesignTimeRequestHandler that provides a simple API for deploying, undeploying, and editing application views on a WebLogic Server.

To learn how to develop a design-time GUI, see Developing a Design-Time GUI.

The Application View

A key component of application integration component of WebLogic Integration is the application view. The application view represents a business-level interface to the specific functionality in an application. An adapter represents a system-level interface to all the functionality in the application. An application view is configured for a single business purpose and contains only the services related to that business purpose. These services require only business-relevant data to be specified in the request document and return only business-relevant data in the response document. Under the covers, the application view combines this business-relevant data with stored metadata necessary for the adapter. The adapter takes both the business-relevant data and the stored metadata and executes a system-level function on the application.

The application view also represents both events and services that support a business purpose. This allows the business user to interact with the application view for all communication with an application. This bidirectional communication is actually supported by two adapter components (the event adapter and service adapter). The application view abstracts this fact from the user and presents them with a unified business interface to the application.

For more information about application views, see Introduction to Using Application Integration in Using Application Integration.

 

---

The Packaging Framework

The ADK packaging framework provides a tool set for packaging an adapter for delivery to a customer. Ideally, all adapters are installed, configured, and uninstalled the same on a WebLogic Server. Moreover, all service adapters must be J2EE compliant. The packaging framework makes creating a J2EE adapter archive (.rar) file, Web application archive (.war) file, the enterprise archive (.ear) file, and WebLogic Integration design environment archive easy.

 

---

Before You Begin

Before you can actually begin developing an adapter, be sure the WebLogic Integration is installed on your computer. See Installing BEA WebLogic Integration and the BEA WebLogic Integration Release Notes for more information.