Abstract:
The present invention provides an HTTP connector implementation to be used by disparate computer systems to communicate with each other over the World Wide Web. In particular, the present invention is directed to business to business communications and meets the specifications of the J2EE Connector Architecture. The present invention provides an HTTP interface that may easily be adapted by existing applications while at the same time shielding the developer from the low level details of the HTTP.

Description:
BACKGROUND OF THE INVENTION  
         [0001]    1. Field of the Invention  
           [0002]    The present invention relates generally to the field of connecting computer systems by a common communication interface. More particularly, the present invention provides a generic HTTP interface that may be utilized by a variety of different computer systems.  
           [0003]    2. Description of the Related Art  
           [0004]    In traditional computing architecture, when it was necessary for disparate computer systems to communicate with each other, developers would produce a layer of software or hardware known as “middleware”. This middleware would translate communication protocols (i.e. ways of communicating) so that one system could exchange data with another. For example, a program running on an International Business Machines mainframe needing to extract data from Digital Equipment Corporation database server would make use of middleware as a standard interface. Over time, the use of such interfaces, known as Application Programming Interfaces (APIs) proliferated. Each with its own special syntax and interface. For networked systems that included a variety of different types of hardware and software interfaces. This quickly became an issue for software development. Most organizations simply do not have the resources to maintain a plurality of different interfaces between the machines their software products need to communicate with.  
           [0005]    To address this problem, IBM Canada Ltd. filed a patent application in Canada, namely patent application number 2,248,634 (the &#39;634 application) which was published on Mar. 24, 2000. The &#39;634 application discloses a framework to allow an application program running on one system to communicate through a standardized communication protocol with a backend running on another system. In our previous example, the IBM mainframe would be running the application, and the DEC database would be the backend application.  
           [0006]    Currently, the most ubiquitous computing network is the Internet. A significant portion of the Internet makes use of the Hypertext Transfer Protocol (HTTP), this is the protocol recognized by web browsers such as Netscape and Internet Explorer and is utilized by web pages on the World Wide Web (WWW). As the use of the WWW increases, the use of HTTP increases as well. In particular, HTTP has become a protocol of choice for the exchange of data between business enterprises connected to the Internet.  
           [0007]    A wide variety of HTTP implementations exist, all of which are very specific. In essence they provide a specific API interface as discussed above. Because of this, existing applications would need to be changed to adapt to each different HTTP implementation.  
           [0008]    Thus, there is a need for a seamless, open and flexible HTTP interface that shields an application from the protocol details and allows existing applications to easily function with a variety of HTTP implementations.  
         SUMMARY OF THE INVENTION  
         [0009]    The present invention relates to a method and system for utilizing an HTTP connector implementation to allow computer systems to communicate using a generic HTTP interface.  
           [0010]    One aspect of the present invention is a system for communicating with one or more target systems by using an HTTP connector, the system having an infrastructure, an application component and an HTTP connector, the application component connected to the HTTP connector via a client view, the HTTP connector connected to the infrastructure by an infrastructure view, and the HTTP connector connected to the one or more target systems for the purpose of exchanging data with the one or more target systems.  
           [0011]    In another aspect of the present invention, there is provided an HTTP connector method, the method having the steps of: requesting a connection to a target system, using an HTTP connector; determining if the connection to the target system has been established, if not, terminating the method; determining the type of interaction desired with the target system and acting upon the type; and returning control to the requesting step.  
           [0012]    In another aspect of the present invention there is provided a system for establishing an HTTP connection, the system comprising: request means for establishing a connection to a target system, using a HTTP connector; testing means to determine if the connection to the target system has been established; selection means for determining the type of interaction desired with the target system; and communication means for communicating with the target system in a manner based upon the type of interaction.  
           [0013]    In another aspect of the present invention there is provided a J2EE Connector Architecture compliant connector, the connector comprising the classes: HTTPConnection, HttpConnectionFactory, HttpConnectionMetaData, HttpConnectionRequestInfo, HttpConnectionSpec, HttpContentRecord, HttpInteraction, HttpInteractionSpec, HttpManagedConnection, HttpManagedConnectionFactory, HttpManagedConnectionMetaData, and HttpResourceAdapterMetaData.  
           [0014]    In another aspect of the present invention there is provided a computer readable medium containing instructions for implementing an HTTP connector method, the instructions comprising the steps of: requesting a connection to a target system, using HTTP; determining if the connection to the target system has been established, if not, terminating the method; determining the type of interaction desired with the target system and acting upon the type; and returning control to the requested step.  
           [0015]    In yet another aspect of the present invention there is provided a computer readable medium containing instructions for creating a J2EE Connector Architecture compliant connector, said instructions comprising the classes: HTTPConnection, HttpConnectionFactory, HttpConnectionMetaData, HttpConnectionRequestInfo, HttpConnectionSpec, HttpContentRecord, HttpInteraction, HttpInteractionSpec, HttpManagedConnection, HttpManagedConnectionFactory, HttpManagedConnectionMetaData, and HttpResourceAdapterMetaData. 
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0016]    For a better understanding of the present invention, and to show more clearly how it may be carried into effect, reference will now be made, by way of example, to the accompanying drawings which aid in understanding an embodiment of the present invention and in which:  
         [0017]    [0017]FIG. 1 is a block diagram of a system utilizing the present invention; and  
         [0018]    [0018]FIGS. 2 a  to  2   c  comprise a flowchart illustrating the logical flow of an embodiment of the present invention. 
     
    
     DESCRIPTION OF THE PREFERRED EMBODIMENTS  
       [0019]    To aid the reader in understanding the architecture in which the present invention may be implemented we now refer to FIG. 1. FIG. 1 is a block diagram of a system utilizing the present invention, shown as  10 .  
         [0020]    System  10  comprises: infrastructure  12 , application component  14 , CCF connector  16 , CCF client view  18  and CCF infrastructure view  20 . Infrastructure  12  is the computer system on which the present invention runs and all the services to which system  10  has access. Application component  14  is a client application running within infrastructure  10 . CCF connector  16  is an interface which allows component  14  to communicate with one or more target systems  22 . Specific to the present invention, component  14  would be communicating with target system  22  to obtain data via an HTTP connection. Connector  16  is the portion of system  10  in which the present invention resides. More specifically the present invention is a connector  16  that provides an HTTP interface. Client view  18  allows application  14  to use well defined and consistent interfaces with a plurality of target systems  22 , via connector  16 . CCF infrastructure view  20  provides an interface between CCF connector  16  and infrastructure  12  so that connector  16  may access such services as error handling, trace logging, security controls or remote access services (RAS).  
         [0021]    The implementation of the present invention follows the specification described in the Java 2 Enterprise Edition (J2EE) Connector Architecture, Proposed Final Draft 2 document. The J2EE specification provides a distributed services-based architecture for implementing electronic business applications. The present invention is a non-transactional connector that implements HTTP communication protocol version 1.0 as specified in Request for Comments (RFC) 1945. Most computer software standardization processes involve the publication of RFC&#39;s to which those interested reply and provide suggestions.  
         [0022]    The present invention has been implemented in Java and as such the description of the preferred embodiment will be Java based. It will be appreciated by those skilled in the art that the use of Java facilitates the description and implementation of the preferred embodiment. However, the preferred embodiment can be adapted to other computer languages. Similarly, the preferred embodiment need not run in the architecture described in FIG. 1, as one skilled in the art will recognize any number of system architectures may make use of the present invention.  
         [0023]    In the preferred embodiment, the present invention consists of the following classes:  
         [0024]    1) HttpConnection  
         [0025]    2) HttpConnectionFactory  
         [0026]    3) HttpConnectionMetaData  
         [0027]    4) HttpConnectionRequestInfo  
         [0028]    5) HttpConnectionSpec  
         [0029]    6) HttpContentRecord  
         [0030]    7) HttpInteraction  
         [0031]    8) HttpInteractionSpec  
         [0032]    9) HttpManagedConnection  
         [0033]    10) HttpManagedConnectionFactory  
         [0034]    11) HttpManagedConnectionMetaData  
         [0035]    12) HttpResourceAdapterMetaData  
         [0036]    We will now discuss the functionality of each of these classes.  
         [0037]    1) HttpConnection  
         [0038]    The following is a list of methods and their signatures implemented by the HttpConnection class:  
         [0039]    HttpConnection(ManagedConnection)  
         [0040]    void call(Interaction, InteractionSpec, Record, Record)  
         [0041]    void close( )  
         [0042]    Interaction createInteraction( )  
         [0043]    boolean getAutoCommit( )  
         [0044]    LocalTransaction getLocalTransaction( )  
         [0045]    HttpManagedConnection getManaged( )  
         [0046]    ConnectionMetaData getMetaData( )  
         [0047]    ResultSetInfo getResultSetInfo( )  
         [0048]    void logTrace(String)  
         [0049]    void setAutoCommit(boolean)  
         [0050]    void setLogWriter(PrintWriter)  
         [0051]    void setManaged(HttpManagedConnection)  
         [0052]    This class represents an application handle to a physical connection. It is created by HttpConnectionFactory and is associated with a particular HttpManagedConnection instance through which the communication With a target system  22  is executed. HttpConnection creates HttpInteraction objects, by the createInteraction method. Since the present invention does not support transactional behaviour, HttpConnection throws a javax.resource.NotSupportedException from the following methods:  
         [0053]    setAutoCommit(boolean)  
         [0054]    getLocalTransaction( )  
         [0055]    getAutoCommit( )  
         [0056]    HttpConnection also throws a NotSupportedException from the getResultSetInfo( ) method. The close request (in the close( ) method implementation) passes the close request to the associated HttpManagedConnection. HttpConnection handles interaction requests, from the HttpInteracton objects it created, in the call( . . . ) method, implemented in addition to the required interface methods. In this method, HttpConnection passes the execution request, along with its instance to the associated HttpManagedConnection.  
         [0057]    2) HttpConnectionFactory  
         [0058]    The following is a list of methods and their signatures implemented by the HttpConnectionFactory class.  
         [0059]    HttpConnectionFactory( )  
         [0060]    HttpConnectionFactory(ConnectionManager)  
         [0061]    Connection getConnection( )  
         [0062]    Connection getConnection(ConnectionSpec)  
         [0063]    ManagedConnectionFactory getManagedConnectionFactory( )  
         [0064]    ResourceAdapterMetaData getMetaData( )  
         [0065]    RecordFactory getRecordFactory( )  
         [0066]    Reference getReference( )  
         [0067]    void logTrace(String)  
         [0068]    void setConnectionManager(ConnectionManager)  
         [0069]    void setManagedConnectionFactory(ManagedConnectionFactory)  
         [0070]    void setReference(Reference)  
         [0071]    The HttpConnectionFactory class represents objects capable of creating active HttpConnections. It is instantiated by and maintains association with the instance of the HttpManagedConnectionFactory. It also contains the instance of the ConnectionManager class which it uses to obtain connections during the connection request, in the getConnection( ) method implementation. If the new connection is requested passing the ConnectionSpec object (getConnection( ) method with the argument), the HttpConnectionFactory verifies that the passed object is an instance of the HttpConnectionSpec, then creates the new instance of the HttpConnectionRequestInfo object, sets its properties using values from the ConnectionSpec and then invokes the allocateConnection method of its associated ConnectionManager instance. HttpConnectionFactory also stores the Referenceable object, providing its accessors in support for factory creation in the server environment. HttpConnectionFactory also stores the instance of the Referenceable object, with accessor methods to support factory creation in the managed environment  
         [0072]    [0072] 3 ) HttpConnectionMetaData  
         [0073]    The following is a list of methods and their signatures implemented by the HttpConnectionMetaData class.  
         [0074]    HttpConnectionMetaData(HttpConnection)  
         [0075]    String getEISProductName( )  
         [0076]    String getEISProductVersion( )  
         [0077]    String getUserName( )  
         [0078]    HttpConnectionMetaData is an object storing the connection information. It contains accessor methods to retrieve the following information:  
         [0079]    EISProductName  
         [0080]    EISProductVersion  
         [0081]    UserName  
         [0082]    4) HttpConnectionRequestInfo  
         [0083]    The following is a list of methods and their signatures implemented by the HttpConnectionRequestInfo class.  
         [0084]    boolean equals(Object)  
         [0085]    String getPassword( )  
         [0086]    String getUserName( )  
         [0087]    int hashCode( )  
         [0088]    void setPassword(String)  
         [0089]    void setUserName(String)  
         [0090]    HttpConnectionRequestInfo is a class containing the connection specific information that does not change the characteristics of the HttpManagedConnection i.e. the same instance of the HttpManagedConnection can be used to create HttpConnection instances with different HttpConnectionRequestInfo. HttpConnectionRequestInfo contains user name and password properties and implements hashCode and equals methods using these properties to calculate hash value and compare two instances for equality, respectively.  
         [0091]    5) HttpConnectionSpec  
         [0092]    The following is a list of methods and their signatures implemented by the HttpConnectionSpec class.  
         [0093]    boolean equals(Object)  
         [0094]    String getPassword( )  
         [0095]    String getUserName( )  
         [0096]    int hashCode( )  
         [0097]    void setPassword(String)  
         [0098]    void setUserName(String)  
         [0099]    HttpConnectionSpec represents the application level access to the connection specific information corresponding to the information contained in HttpConnectionRequestInfo. During the servicing of a connection request (getConnection( ) method implementation), HftpConnectionFactory copies values from HttpConnectionSpec to HttpConnectionRequestInfo. HttpConnectionSpec contains user name and password properties and implements hashCode and equals method that use these properties to calculate hash value and compare two instances for equality respectively.  
         [0100]    6) HttpContentRecord  
         [0101]    The following is a list of methods and their signatures implemented by the HttpContentRecord class.  
         [0102]    Object clone( )  
         [0103]    String getRecordName( )  
         [0104]    String getRecordShortDescription( )  
         [0105]    void read(InputStream)  
         [0106]    void setRecordName(String)  
         [0107]    void setRecordShortDescription(String)  
         [0108]    void write(OutputStream)  
         [0109]    HttpContentRecord is a class implementing javax.resource.cci.Record and javax.resource.cci.Streamable interfaces from the J2EE specification. It represents the data object passed to the execute method of the HttpInteraction class and containing the information received from target system  22 . The present invention uses this object internally to handle requests of the execution from applications that do not provide the output record i.e. invoke the execute( . . . ) method in HttpInteraction with only an input record argument.  
         [0110]    7) HttpInteraction  
         [0111]    The following is a list of methods and their signatures implemented by the HttpInteraction class.  
         [0112]    HttpInteraction(Connection)  
         [0113]    void clearWarnings( )  
         [0114]    void close( )  
         [0115]    Record execute(InteractionSpec, Record)  
         [0116]    boolean execute(InteractionSpec, Record, Record)  
         [0117]    Connection getConnection( )  
         [0118]    RecordFactory getRecordFactory( )  
         [0119]    ResourceWarning getWarnings( )  
         [0120]    void logTrace(String)  
         [0121]    void setLogWriter(PrintWriter)  
         [0122]    HttpInteraction represents objects used by an application  14  to perform interaction with target system  22  through the use of the present invention. A HttpInteraction object is created by HttpConnection and HttpConnection maintains a reference to the created object. The execution request, implemented through either of the execute methods of HttpInteraction is passed to the associated HttpConnection instance for further processing through the invocation of the protected call method and passing the arguments of the execute method, HttpInteractionSpec, input record and output record. If the execute method with only input record was invoked, HttpInteraction creates a new instance of the HttpContentRecord and passes it to the call method as the output record. Since HttpInteraction does not maintain any state, the implementation of the close method does not perform any operation except verifying that it is not in an already closed state. If it is, i.e. the close method had been previously invoked, the method throws javax.resource.spi.IllegalStateExcepton. This exception is also thrown if one of the execute methods is invoked when the HttpInteraction has been closed.  
         [0123]    8) HttpInteractionSpec  
         [0124]    The following is a list of methods and their signatures implemented by the HttpInteractionSpec class.  
         [0125]    HttpInteractionSpec( )  
         [0126]    String getContentType( )  
         [0127]    Hashtable getHeaderFields( )  
         [0128]    int getInteractionVerb( )  
         [0129]    void setContentType(String)  
         [0130]    void setHeaderFields(Hashtable)  
         [0131]    void setInteractionVerb(int)  
         [0132]    The HttpInteractionSpec class implements interaction specific properties of the present invention. These properties include the interaction mode (mapped to the appropriate request method in the HttpManagedConnection), a value indicating one of the following interaction types:  
         [0133]    a) synchronous send and receive—the request is sent through connector  16  to target system  22  and the reply is passed back to the invoking application  14 ;  
         [0134]    b) synchronous send—the data is sent to target system  22 ; and  
         [0135]    c) synchronous receive—the data is received from target system  22 .  
         [0136]    These values are referred to in the J2EE Connector Architecture as: SYNC_SEND_RECEIVE, SYNC_SEND and SYNC_RECEIVE. In the interest of readability in the figures and the specification, we refer to these values as: “send_receive”, “send”, and “receive” respectively.  
         [0137]    Another property characterizing the interaction that can be specified on the HttpInteractionSpec are request headers. An application  14  using the present invention through connector  16  provides these as a hash table of keys and values. The class implementation also provides direct accessors to the contents type of the request, which is then automatically written as one of the http headers with the key “Content-Type”.  
         [0138]    9) HttpManagedConnection  
         [0139]    The following is a list of methods and their signatures implemented by the HttpManagedConnection class.  
         [0140]    HttpManagedConnection(Subject, ConnectionRequestInfo, String)  
         [0141]    void addConnectionEventListener(ConnectionEventListener)  
         [0142]    void associateConnection(Object)  
         [0143]    void call(HttpConnection, InteractionSpec, Record, Record)  
         [0144]    void cleanup( )  
         [0145]    void close(HttpConnection)  
         [0146]    void destroy( )  
         [0147]    void errorOccurred(Exception)  
         [0148]    Object getConnection(Subject, ConnectionRequestInfo)  
         [0149]    LocalTransaction getLocalTransaction( )  
         [0150]    PrintWriter getLogWriter( )  
         [0151]    ManagedConnectionMetaData getMetaData( )  
         [0152]    Subject getSecurityContext( )  
         [0153]    String getUserName( )  
         [0154]    XAResource getXAResource( )  
         [0155]    boolean isDirty( )  
         [0156]    void logTrace(String)  
         [0157]    void receive(Streamable, InputStream)  
         [0158]    void removeConnectionEventListener(ConnectionEventListener)  
         [0159]    void send(Streamable, OutputStream)  
         [0160]    void setDirty(boolean)  
         [0161]    void setLogWriter(PrintWriter)  
         [0162]    HttpManagedConnection is the class representing the HTTP protocol physical connection to target system  22 , specified through a URL. The application level access to the connection is provided through the application level handles HttpConnection which it can instantiate. HttpManagedConnection supports multiple handles, however only the most recently created handle can be used to perform interactions. The access from any other handle, before the last handle created issues close notification, is treated as an error and causes an IllegalStateException to be thrown. The validation and current handle maintenance is implemented through storing handles in a stack data structure with the valid handle at the top. The stack data structure is internal to the class implementation, and is not exposed outside the class and only used by its methods. Each access from the HttpConnection is validated against this data structure and the appropriate action is taken. The main methods implemented by the Http ManagedConnection class as are follows:  
         [0163]    a) void associateConnection(Object)—in this method, the passed HttpConnection object is disassociated from its current HttpManagedConnection, using the close method invocation and then associated with the managed connection as the most recent application level handle on top of the handles stack.  
         [0164]    b) void call(HttpConnection, InteractionSpec, Record, Record)—this method is used by HttpConnection to pass an execution request. HttpManagedConnection first verifies that the request has a valid handle passed as an argument and that the passed InteractionSpec object is the instance of the HttpInteractionSpec. Next, it creates a connected HttpURLConnection to the target system  22  URL using standard java.net library method invocation URL.openConnection( ). After the HttpURLConnection is created, the headers set on the HttpInteractionSpec are set on the HttpURLConnection as request properties the next action depends on the InteractionVerb property specified in HttpInteractionSpec. For send_receive the HttpURLConnection request method is set to “POST” and both doInput and doOutput properties of HttpURLConnection are set to true. For the send, the request method is set to PUT, doOutput to true and dolnput to false, and finally, for the receive, the request method is set to GET, doOutput to false and doInput to true.  
         [0165]    An input record is a record that is sent to target system  22 . Application  14  fills the input record with request data and sends it to the target  22  via connector  16 . Thus, it is input data to target system  22 . Similarly, an output record contains data output from target system  22  which is provided to application  14 .  
         [0166]    At the next step, the HttpURLConnection is connected and then the contents of the input record (extracted by viewing record as an implementation of the Streamable interface) is written to its output stream For send_receive and send and/or the content of the output record is read from the HttpURLConnection input stream for the send_receive and receive. Next, the headers returned by the HttpURLConnection are copied to the hash table and set in the HttpInteractionSpec to be returned to the application. The last step in the method is disconnecting the HttpURLConnection. If, during its execution the call method encounters a communication error, it sets an ERROR_OCCURRED event and then throws a CommException to the invoker.  
         [0167]    c) void cleanup( ) this method cleans up the internal state of the HttpManagedConnection by emptying the handles stack.  
         [0168]    d) void close(HttpConnection)—this method is invoked to forward an application close request on the connection handle. The HttpManagedConnection removes the handle that invoked the method from the top of the stack and sets a CONNECTION_CLOSED event.  
         [0169]    e) void destroy( )—this method permanently cleans up the internal state of the HttpManagedConnection by emptying and deallocating the handles stack and setting the HttpURLConnection to null.  
         [0170]    f) Object getConnection(Subject, ConnectionRequestInfo)—in this method, new connection handle is created and put on the top of the handles stack.  
         [0171]    Since the HTTP Connector does not support transactional behaviour, i.e. the ability to roll back units of work, the methods getXARespirce( ) and getLocalTransaction( ) throw the NotSupportedException.  
         [0172]    10) HttpManagedConnectionFactory  
         [0173]    The following is a list of methods and their signatures implemented by the HttpManagedConnectionFactory class.  
         [0174]    Object createConnectionFactory( )  
         [0175]    Object createConnectionFactory(ConnectionManager)  
         [0176]    ManagedConnection  
         [0177]    createManagedConnection(Subject, connectionRequestInfo)  
         [0178]    boolean equals(Object)  
         [0179]    PrintWriter getLogWriter( )  
         [0180]    String getURL( )  
         [0181]    int hashCode( )  
         [0182]    void logTrace(String)  
         [0183]    ManagedConnection  
         [0184]    matchManagedConnections(Set, Subject, ConnectionRequestInfo)  
         [0185]    void setLogWriter(PrintWrter)  
         [0186]    void setURL(String)  
         [0187]    The HttpManagedConnectionFactory class instance creates HttpManagedConnection objects. Each created object is passed the connection URL of the target system  22  and the logWriter properties of the factory. The logWriter is a class (PrintWriter to be exact) which is used by the HttpManagedConnectionFactory to record its trace and error information. When it is set on the HttpManagedConnectionFactory, the J2EE specification Connector architecture specification, requires it to pass the instance to every managed connection it creates.  
         [0188]    11) HttpManagedConnnectionMetaData  
         [0189]    The following is a list of methods and their signatures implemented by the HttpManagedConnectionMetaData class.  
         [0190]    HttpManagedConnectionMetaData(HttpManagedConnection)  
         [0191]    String getEISProductName( )  
         [0192]    String getEISProductVersion( )  
         [0193]    int getMaxConnections( )  
         [0194]    String getUserName( )  
         [0195]    HttpManagedConnectionMetaData provides information about the connector  16  such as target system  22  product and version, maximum number of connections supported by the target system  22  and the name of the user.  
         [0196]    12) HttpResourceAdapterMetaData  
         [0197]    The following is a list of methods and their signatures implemented by the HttpResourceAdapterMetaData class.  
         [0198]    String getAdapterName( )  
         [0199]    String getAdapterShortDescription( )  
         [0200]    String getAdapterVendorName( )  
         [0201]    String getAdapterVersion( )  
         [0202]    String [] getInteractionSpecsSupported( )  
         [0203]    String getSpecVersion( )  
         [0204]    boolean supportsExecuteWithInputAndOutputRecord( )  
         [0205]    boolean supportsExecuteWithInputRecordOnly( )  
         [0206]    boolean supportsLocalTransactionDemarcation( )  
         [0207]    HttpResourceAdapterMetaData provides an application  14  with the characteristics of the resource adapter terms such as name, description, vendor name, adapter version and specification version supported. It also contains information describing which optional features of the specification have been implemented, such as names of InteractionSpec implementation classes, which type of execute method connectors are supported and whether it supports local transactions. Here we use the term “resource adapter” as it is the terminology utilized by the J2EE. Connector architecture specification. For the purposes of the present specification and claims, the terms “resource adapter” and “connector” (i.e. connector  16 ), are interchangeable  
         [0208]    To illustrate how the above described classes implement the present invention, we refer now to FIGS. 2 a  to  2   c  which are a series of flowcharts illustrating the process of an embodiment of the present invention. The process is shown generally as  30 .  
         [0209]    Referring first to FIG. 2 a , beginning at step  32  an application  14  (see FIG. 1), requests a connection to a target system  22  using the HTTP protocol by invoking: execute(HttpInteractionSpec,inputRecord,outputRecord) of class HttpInteraction at step  34 . At step  36  if an outputRecord was not specified, then one is created at step  38 . At step  40  the call method of class HttpConnection is invoked by: call(HttpInteraction, HttpInteractionSpec, inputRecord, outputRecord). At step  42  the call method of class HttpManagedConnection is invoked by: call(HttpConnection, HttpInteractionSpec, inputRecord, outputRecord). Block  44  serves as a transfer to FIG. 2 b.    
         [0210]    Referring now to FIG. 2 b , at step  46  if the current handle (i.e. the instance of HttpConnection) is not the most current, an IllegalStateException is thrown at step  48  and process  30  terminates. Should the current handle be valid, process  30  moves to step  50  where a connection with target system  22  is made by invoking URL.openConnection( ) of the standard java.net library. At step  52  it is determined if a valid connection has been established. If a valid connection has not been established, control moves to step  54  where a CommException is thrown and process  30  ends. If a valid connection has been established, then process  30  continues. Block  56  serves as a transfer to FIG. 2 c.    
         [0211]    Referring now to FIG. 2 c , at step  58  the value of the InteractionVerb contained within the HttpInteraction instance is examined. The value of InteractionVerb may be one of: receive, send, or send_receive. For each value one of the following steps are taken:  
         [0212]    a) For receive, at step  60  requestMethod of HttpURLConnection is set to GET, dolnput is set to true and doOutput is set to false. Data is then received from the target system  22  at step  68  and provided to application  14 .  
         [0213]    b) For send, at step  62  HttpURLConnection request method is set to PUT, doInput is set to false and dooutput is set to true. Data is then sent to the target system  22  at step  70 .  
         [0214]    c) For send_receive, at step  64  HttpURLConnection request method is set to POST, doInput is set to true and doOutput is set to true. Properties of the HttpURLConnection data is next sent from application  14  to the target system  22  at step  66  and then data is received for application  14  from the target system  22  at step  68 .  
         [0215]    At step  72  process  30  ends and control is returned to application  14 .  
         [0216]    Although the above disclosure mentions the Internet or WWW as an example of a network on which the present invention may be utilized, it is not the intent of the inventors to exclude Intranets, Extranets, or any form of network using an HTTP protocol, including but not limited to: wireless, twisted pair, cable and satellite. In a special case, connector  16  and target system  22  may reside on the same system  10 . Similarly System  10  may be any computing device capable of supporting the present invention, including but not limited to: standalone computer systems, handheld devices and television settop boxes.  
         [0217]    Although the invention has been described with reference to certain specific embodiments, various modifications thereof will be apparent to those skilled in the art without departing from the spirit and scope of the invention as outlined in the claims appended hereto.