Examples

Example, a NXTware J-Platform SE component might look up foreign
exchange information in an existing RPC, Entera or mainframe application,
and make it available on the bus as a service.

One of the most important SE is the BPEL service engine, which supports a
standards-based language for the orchestration of components and work flow
in business processes.

Similar to the SE, a Binding Component (BC) isolates the communication
style and/or protocol used by an external systems, when it communicate with
NXTware ESB.

Example, a BC encapsulates communications with HTTP or .NET system
making sure to keep its protocol external to the NXTware ESB; while another
BC may use IBM MQ as a communications channel to external systems.

Note: The NXTware J-Platform components can serve as both ESB Service
Engines and Binding Components. (More on them in a moment.)

Internal Communication

No mater how they communicate with their resources (legacy or
contemporary) all components on the NXTware ESB communicate with one
another using messages. There is no API integration –at all. This eliminates
the real-time and development bottlenecks associated with other
synchronous models.

Every participating component on the NXTware EBS communicates using JMS,
thus insuring that these are very loosely coupled components. That
independence gives the NXTware ESB its flexibility and its users the ability to
quickly re-purpose applications and their capabilities with out writing new
code.

Message Data

All data passed along the NXTera ESB is passed in the form of XML. Once on
the bus all data is normalized as XML with all of the connection or protocol
information removed. Upon leaving the bus the message is de-normalized so
as to meet the expectations of the external system.

 

Tables

NXTware comes with a series of Binding Components. They include:

Table 1. NXTware Binding Components
Binding	Description
RPC	Accepts incoming messages via RPC. T his also includes an RPC client component that can make requests via RPC.
HTTP	Accepts incoming messages via HTTP . This also includes an HTTP invoker component that can send messages via HTTP.
FTP	Sends messages to an FTP server as files . Also a component to poll an FTP server for incoming file/messages .
JMS	Sends and receives messages via JMS.
JCA	Implements the required support framework of JCA 1.5 (Java Connector Architecture). T his component allows compatible connector (typically JMS connector at this time) to run with NXTware applications . T his component can provide a high performance interface to JMS brokers .
VFS	A component implementing access to and from file systems (including OS file systems , jars and zips , Samba (CIFS), etc ).
SAAJ	Invokes web services using SOAP with Attachments and Apache AXIS.
Xfire	Supports the XFire lightweight SOAP stack –allowing NXTware POJOs and to be bound as web services .

Table 2. NXTware Service Engine Components
Engines	Description
Legacy	Support the NXTera/Entera transport –allowing legacy C C++, COBOL objects to be bound the NXTware Enterprise Services Bus
NXTware Native	NXTware native services that enable Java service, legacy to XML conversion, and IBM mainframe CTG connectivity.
XSLT based Transformation	A component for trans forming incoming normalized messages according to a deployed XSLT template.
XSQL	A component supporting Oracle’s tool for transforming SQL query to XML or persisting XML to database.
Generic scripting	A component enabling any JSR 223 compliant scripting language to be plugged into NXTware.
BPEL	Business Process Execution Language for Web Services . A standards based language for the orchestration of components and work flow in business processes .
Validation	A component providing schema validation of messages .
Quartz	A component that works with the Quartz scheduling engine, allows you to set multiple scheduled service invocation using NXTware.
Drool	A component for rules based routing of messages . Flexible XML schema based “domain specific language” can be used to specify rules.
Groovy	A component for very flexible implementation of services , transformers and routing logic . The code can be written in the Groovy scripting language and interpreted by the component at runtime.

NXTware J-Platform

The NXTware J-Platform is a container for the deployment of Java objects,
both complex and perfectly ordinary Java objects (POJO’s). These objects
can provide business logic services, legacy integration services or ESB
service engine/binding component services.

When used in an ESB environment NXTware J-Platform acts as a Service
Engine for consumers on the service bus and as a binding component for
legacy applications. This allows legacy apps to participate in the enterprise
service bus.

NXTware ESB enables NXTware J-Platform to act as a service engine
providing normalized data –stripping out protocol and transforming the data
to XML –to the bus. In the other direction NXTware J-Platform allows legacy
Entera or mainframe applications to consume other services provided by by
the bus.

This development tool kit is simple to use and its basic functionality should
be familiar to anyone that has worked with CORBA or RPC-based multi-tiered
solutions like NXTera/Entera.

NXTware J-Platform and NXTera/Entera

Ease of use

One of the benefits for NXTera/Entera users of using NXTware is the
simplicity and familiarity. Entera developers will be instantly familiar with
the design of NXTware J-Platform and the use of tools like NXTMAKE to
create Java stubs and clients.

Similar to tools in Entera, NXTMAKE is a NXTWare J-Platform definition file
language compiler, which can generate client and server stubs in several
languages.

Composite Architecture

The NXTware J-Platform provides NXTera/Entera users with an integration
platform for Java and contemporary multi-platform interoperable APIs
(CORBA, web services, etc) and client bindings. New Java clients and
servers can be created that interact as providers or consumers of legacy
NXTera/Entera services. These new clients and servers can also work
independently of the NXTera/Entera environment supporting Java and .Net
clients, where NXTware J-Platform acts as Java version of NXTera/Entera.

 

Summary

NXTware Evolution Server integrates existing applications on any platform
with contemporary modern SOA architectures. The server provides the ability
to enable legacy applications running on any platform to serve as SOA
service providers and consumers transparently on any transport –such as
RPC (SOAP, CORBA, Entera/NXTera, XML RPC) and Messaging (MQ, JMS,
MSMQ).

Additionally, NXTWare delivers JCA integration and XSLT transformation via
its JBI based Enterprise Service Bus (ESB). The open standards based ESB
supports bindings with a larger variety of system types, while implementing
the latest standards for transformation, routing and scripting services.

In conclusion, the NXTware Evolution Server is a powerful integration
solution that leverages many legacy and open standards to integrate
enterprise applications in an implementation-independent fashion, at a
coarse-grained service level (leveraging the principles of service-oriented
architecture) via an event-driven and XML-based messaging engine.

NXTware Evolution server provides an abstraction layer which allows
integration architects to exploit the value of messaging without writing
integration code.