Muster 'Worklight Adapters and the Worklight to Microsoft .NET request-response'

Bei Worklight-Adaptern handelt es sich um den serverseitigen Code von Anwendungen, die auf der Worklight-Plattform für mobile Anwendungen implementiert sind und dort gewartet werden. Adapter stellen eine Verbindung vom Worklight-Server zu Unternehmensanwendungen her, beispielsweise zu denen, die in WebSphere Message Broker ausgeführt werden. Die folgende Sequenz durchläuft einen typischen Datenfluss zwischen einer mobilen Anwendung und einem Microsoft .NET-Web-Service, der in Message Broker ausgeführt wird:

  1. Der Adapter stellt eine Gruppe von Services bereit, die als Prozeduren bezeichnet werden. Der Adapter und die mobile Anwendung werden im Worklight-Server implementiert.
  2. Die mobile Anwendung ruft Prozeduren auf, indem Ajax-Anforderungen (WL.Client.invokeProcedure) ausgegeben werden. Die Parameter für die Prozedur werden als in JSON formatierte Daten übergeben.
  3. Die Prozedur wandelt die JSON-Parameter in eine XML-Nachricht für die SOAP-Anforderung um.
  4. Die Prozedur ruft den Microsoft .NET-Web-Service auf, der in Message Broker ausgeführt wird.
  5. Der Microsoft .NET-Web-Service gibt Daten als XML-SOAP-Antwort zurück.
  6. Die XML-formatierten Daten werden vom Worklight-Server in JSON umgewandelt.
  7. Die JSON-Daten werden zurück zur ursprünglichen mobilen Anwendung gesendet.

Dieses Muster generiert einen Worklight-Adapter, der jede ausgewählte Methode in Ihrer .NET-Klasse aufrufen kann. Der Adapter wandelt JSON-Anforderungen aus mobilen Anwendungen in Web-Service-Anforderungen in Ihrer Microsoft .NET-Klasse um. Beispielsweise befinden sich die folgenden C#-Methoden in einer Klasse mit der Bezeichnung RetailBank und wurden für eine Musterinstanz mit der Bezeichnung MyBank ausgewählt:

        public static string GetBalance(string accountNumber, out string lastUpdated);
        public static string TransferMoney(string sourceAccountNumber, string targetAccountNumber, string value);
        public static string FindMissingAccount(string name, ref string lastKnownAccountNumber);

Das folgende JavaScript-Snippet zeigt, wie eine mobile Anwendung die Methode GetBalance aufrufen kann:

        var invocationData = {
                adapter : "MyBank",
                procedure : "GetBalance",
                parameters : [ accountNo ]};
        
        var options = {
            onSuccess:lang.hitch(this, this.onResult),
            onFailure:lang.hitch(this, this.onError)};

        WL.Client.invokeProcedure(invocationData, options);

Zu Testzwecken kann der implementierte Worklight-Adapter mithilfe eines Web-Browsers über die folgende URL aufgerufen werden:

http://localhost:8080/dev/invoke?adapter=MyBank&procedure=GetBalance&parameters=%5B123456789%5D

Generierte Dateien

In diesem Abschnitt werden die Dateien erläutert, die für den Worklight-Adapter generiert wurden.

Worklight-Adapter

Das Muster erstellt einen Worklight-Adapter mit zwei Konfigurationsdateien. Bei der ersten Konfigurationsdatei (MyBank.xml) handelt es sich um die XML-Datei des Adapters. Mit der XML-Datei des Adapters wird die Verbindung zu Message Broker konfiguriert und es werden die Prozeduren vereinbart, die vom Adapter für mobile Anwendungen und andere Adapter verfügbar gemacht werden. Im folgenden Beispiel wird die generierte XML-Konfigurationsdatei des Adapters gezeigt:

    <?xml version="1.0" encoding="UTF-8"?>
    <wl:adapter name="MyBank"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:wl="http://www.worklight.com/integration"
        xmlns:http="http://www.worklight.com/integration/http">
    
        <displayName>MyBank</displayName>
        <description>Worklight integration adapter for the Microsoft .NET service</description>
        <connectivity>
            <connectionPolicy xsi:type="http:HTTPConnectionPolicyType">
                <protocol>http</protocol>
                <domain>localhost</domain>
                <port>7800</port>
            </connectionPolicy>
            <loadConstraints maxConcurrentConnectionsPerNode="99" />
        </connectivity>
    
        <procedure name="GetBalance"/>
        <procedure name="TransferMoney"/>
        <procedure name="FindMissingAccount"/>
    </wl:adapter>

Viele der Werte in dieser XML-Datei des Adapters werden aus Musterparametern konfiguriert (z. B. displayName, domain und port). Es wird auch gezeigt, dass für jede .NET-Methode eine Prozedur (procedure) konfiguriert wurde. Prozeduren definieren einen Prozess für den Zugriff auf die Operationen, die vom Microsoft .NET-Web-Service verfügbar gemacht werden. Für jede Operation im Web-Service ist eine procedure vorhanden.

Das Muster generiert auch eine JavaScript-Datei (MyBank-impl.js), die die Implementierungsfunktionen für jede Prozedur enthält:

    var targetNamespace = "urn://bankingapplication/retailbank_V1";
    
    function PrepareWebService(method, parameters, path) {
        var request =
            '<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:tns="' + targetNamespace + '">' +
                '<soap:Header/>' +
                '<soap:Body>' +
                    '<tns:' + method + '>';
    
        for (var key in parameters) {
            request += '<' + key + '>' + parameters[key] + '</' + key + '>';
        }
    
        request += '</tns:' + method + '>' +
                '</soap:Body>' +
            '</soap:Envelope>';
    
        var input = {
            method : 'post',
            returnedContentType : 'xml',
            path : path,
            body : {
                contentType: 'application/xml; charset=utf-8',
                content: request
            }
        };
        return input;
    }
    
    var targetPath = "/retailbank";
    
    function sendRequest(name, input) {
        var response = WL.Server.invokeHttp(input);
        WL.Logger.log(response);
    
        if (response.Envelope) {
            var data = response.Envelope.Body;
            data = data[name];
            response.result = data;
            delete response.Envelope;
            WL.Logger.log(response);
        }
        return response;
    }

    function GetBalance(accountNumber) {
        var parameters = new Object();
        parameters['accountNumber'] = accountNumber;
        var input = PrepareWebService('GetBalance', parameters, targetPath);
        WL.Logger.debug('SOAP request: ' + input.body.content);
        return sendRequest('GetBalanceResponse', input);
    }
    
    function TransferMoney(sourceAccountNumber, targetAccountNumber, value) {
        var parameters = new Object();
        parameters['sourceAccountNumber'] = sourceAccountNumber;
        parameters['targetAccountNumber'] = targetAccountNumber;
        parameters['value'] = value;
        var input = PrepareWebService('TransferMoney', parameters, targetPath);
        WL.Logger.debug('SOAP request: ' + input.body.content);
        return sendRequest('TransferMoneyResponse', input);
    }
    
    function FindMissingAccount(name, lastKnownAccountNumber) {
        var parameters = new Object();
        parameters['name'] = name;
        parameters['lastKnownAccountNumber'] = lastKnownAccountNumber;
        var input = PrepareWebService('FindMissingAccount', parameters, targetPath);
        WL.Logger.debug('SOAP request: ' + input.body.content);
        return sendRequest('FindMissingAccountResponse', input);
    }

Der generierte JavaScript-Code wandelt die in einer JSON-Anforderung bereitgestellten Parameter in eine XML-SOAP-Nachricht um. Die Konvertierung von JSON in SOAP wird in der Funktion PrepareWebService implementiert. Die SOAP-Anforderung wird an Worklight übergeben und ruft dort Ihren Microsoft .NET-Web-Service in der Funktion WL.Server.invokeHttp auf.

Beispielnachrichten

Die XML-Nachricht der SOAP-Anforderung für einen Aufruf an die Operation GetBalance, die durch den Microsoft .NET-Web-Service implementiert wurde, sieht bei Verwendung der Accountnummer 123456789 folgendermaßen aus:

    <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:tns="urn://bankingapplication/retailbank_V1">
        <soap:Header/>
        <soap:Body>
            <tns:GetBalance>
                <accountNumber>123456789</accountNumber>
            </tns:GetBalance>
        </soap:Body>
    </soap:Envelope>

Der Worklight-Server wandelt die XML-SOAP-Antwort für die ursprüngliche mobile Anwendung automatisch aus dem Microsoft .NET-Web-Service in JSON um:

    {
      "errors": [],
      "info": [],
      "isSuccessful": true,
      "result": {
        "NS1": "urn://bankingapplication/retailbank_V1",
        "lastUpdated": "20/06/2012 11:46:52",
        "returnValue": "1000.00"
      },
      "statusCode": 200,
      "statusReason": "OK",
      "warnings": []
    }

Zurück zur Spezifikation des Musters 'Worklight to Microsoft .NET: request-response'