Data structure and functions of JFT/API interface are described, along with the main concepts regarding access to the FastTrack server: connections, data subscriptions, transactions, queries, etc...
The first chapter FastTrack Overview introduces the main basic concepts of FastTrack with a short overview of system architecture.
The second chapter Data Distribution explains how data are distributed, searched and retrieved inside FastTrack.
Chapter three JFT/Api Details describes the main peculiarities of the Java Access Point to FastTrack: lifecycle, communication model, exception handling, threads synchronization, etc...
Following chapters contain the effective and detailed descriptions of the Api
subdivided in two different packages:
it.list.jft
and
it.list.jft.event
,
Finally, after all details on specific JFT/Api functions,
a few examples of Java application are given
in order to exploit almost all major capabilities offered by JFT/Api and
to be possibly fruitfully studied and used as starting point for effectives
Java programs that links to a true FastTrack server.
FastTrack Overview
This chapter explains the basic concepts of FastTrack that are
fundamental in developing Java applications that access FastTrack
services using this JFT/Api.
There are three different architectural levels for the various components, depending on the service they implement:
The set of FastTrack modules managing communication with the external world makes up the basic level. These are organized into two categories: Adapters, through which FastTrack can access other systems or electronic markets, and Access points, which give access to FastTrack from the outside. Finally, the enterprise level hosts the functional applications in FastTrack (Engine level).
FastTrack is a distributed system. The computing process is subdivided into several steps. It is not performed by one individual component, but by a series of elements (Application Servers or Services) each designed to carry out its particular part of the process.
Queries made to the FastTrack platform and answers to these queries both go through the Access Point Level.
The Access Point Level:
Using this library it is possibile to construct Java applications and/or applets that may communicate with one or more FastTrack servers and/or services.
Obviously the effective access to these services is
managed/controlled/verified in relation to various credentials
(user names, passwords, authorization keys, etc...)
that an external application must presents in order
to be properly authorized to enter in the system.
Data Distribution
Data are distributed through a publish/subscribe protocol, in which
producers and consumers exchange messages to access the data. There are
many data structure exchanged within FastTrack. Each data structure is
called EntityClass and it
is structured in many fields of many different types (numbers, strings,
etc...). Each set of values that corresponds to these fields is an
instance of the EntityClass. This instance id called Entity. Applications may modify
or access an entire Entity (all the fields of an instance of an
EntityClass) or a subset of these fields defined using a mask.
From now on we call:
Example:
a FastTrack order-manager publishes all records that describes new received or changed orders.
Only certain EntityClasses of a FastTrack server may be published and then subscribed. The documentation of each FastTrack server clearly says which EntityClasses can be published/subscribed.
Example:
a customer subscribes to the orders handled by FastTrack.
Subscriptions in JFT/Api are modelled by Subscription. Among other things within subscriptions it's possible to have:
Example:
A client queries for all orders sent by a specific operator.
Only certain queries (each identified by a unique number) are permitted with a FastTrack server. The documentation of each FastTrack server clearly lists which queries (i.e. numbers) are permitted and with which arguments.
Example:
the client asks the server to issue an order on a specific product.
This operation may take a long period to be completed by the server and so the client have to monitor it until a good or bad (commited vs aborted) final result. This monitoring must be always done by the client, even after a client-restart on previous initiated (past) transactions. Only when the client see the final commited result it may assume that the transaction was succesfully.
See Transaction Usage to see all specific attributes of a transaction and how to monitor past transactions.
Example:
an order-manager service may reside on port 1234 of hostmyFTserver.myDomain.com
(or something like 194.91.195.33) and beeing namedOrderManager
See Connection Usage to see all specific attributes that define a connection.
In addition the Context. metaphor has
been introduced in order to group together connections (and
corresponding subscriptions, transactions, queries, etc..) that refer
to the same set of related FastTrack services.
JFT/Api Details
The JFT/Api library may be used starting with Sun JDK 1.7.
See Listener interface for specific details.
See the LifeCycle interface and its related sub-interfaces to understand how this behaviour is controlled and regulated.
See
it.list.jft
Data Model
and
it.list.jft.event
Data Model
to familiarize with the hierarchy and relationship of the various interfaces.
Where is the first initial entry point to use this library?It's available in the singleton that implements the JFT interface. Using that singleton, referenced by the THIS constant, every programmer may starts to use the library accessing all its functionalities.