Kapitel 6. Anwendung / Funktionalität

Die neu zu erstellende Nodeklasse muss von der abstrakten Superklasse Node erben. Sie muss einen parameterlosen Konstruktor („default constructor“) besitzen.

Außerdem kann die Methode getWorkerClassName() überschrieben werden. Als standardmäßigen Rückgabewert liefert diese als Rückgabewert den voll qualifizierten Klassenname des Node, wobei Node durch Worker ersetzt wird sowie worker als zusätzliche Namespace-Ebene eingefügt wird (Bsp: com.acme.jadiceserver.ExampleNode.getWorkerClassName() liefert com.acme.jadiceserver.worker.ExampleWorker).

Haben Sie eine andere Paketstruktur gewählt, so kann diese Methode überschrieben werden, um den voll qualifizierten Klassennamen der korrespondierenden Workerklasse zu liefern:

package com.mycompany.jadice.client;

import com.levigo.jadice.server.Node;

public class DemoNode extends Node {

  public String getWorkerClassName() {
    // Full qualified class name of the worker class
    return "com.mycompany.jadice.worker.DemoWorker";
  }

Soll es möglich sein, dass dem NodeWorker zur Laufzeit Parameter übermittelt werden, so kann dies durch weitere Methoden in der Node-Implementierung erfolgen. Dabei ist zu beachten, dass alle Objekt- und statischen Attribute das Interface Serializable implementieren müssen, da diese über JMS serialisiert und transportiert werden (siehe Abschnitt „Konfiguration des eingebetteten Messagebrokers“).

public String getMyParameter() {
  // Should be modifiable via a setter method
  return "a Parameter";
}

Der selbst implementierte Node muss sowohl client- als auch serverseitig im Klassenpfad eingebunden werden und kann genau wie die im Abschnitt „Anwendungsszenarien samt Code-Beispielen“ gezeigten Nodes in eigene Workflows eingebettet werden.

Die Workerklasse, in der die Konvertierung durchführt wird, erbt von der abstrakten, generischen Superklasse NodeWorker<N>, wobei der Typ-Parameter <N>für die zugehörige Node-Klasse steht.

Hier ist die abstrakte Methode work() zu implementieren, in der die serverseitige Konvertierung durchführt wird.

package com.mycompany.jadice.server;

import java.io.InputStream;

import com.levigo.jadice.server.core.NodeWorker;
import com.levigo.jadice.server.shared.types.BundledStream;
import com.levigo.jadice.server.shared.types.Stream;
import com.levigo.jadice.server.shared.types.StreamDescriptor;
import com.mycompany.jadice.client.DemoNode;

public class DemoWorker extends NodeWorker<DemoNode> {

  protected void work() throws Throwable {
    // Parameter as defined in the example above
    String myParam = getNode().getMyParameter();

    // Retrive input data
    for (Stream stream : getInputBundle()) {
      InputStream unprocessedIS = stream.getInputStream();
      // Meta data of the received stream
      StreamDescriptor unprocessedSD = stream.getDescriptor();

      // Method to process the data (not shown here)
      InputStream processedIS = process(unprocessedIS, myParam);

      // Meta data of the processed data
      // unprocessedSD is set as "parent"
      StreamDescriptor processedSD = new StreamDescriptor(unprocessedSD);
      processedSD.setDescription("<Beschreibung>");
      processedSD.setMimeType("<MIME Type>");
      processedSD.setFileName("<Dateiname>");

      // Link result result with its meta data
      Stream result = new BundledStream(processedIS, processedSD);
      // pass the result
      getOutputBundle().addStream(result);
    }
  }
  }

Der auf diese Weise implementierte NodeWorker muss nur im Klassenpfad des jadice server eingebunden werden und wird bei Verwendung des zugehörigen Nodes aus Beispiel 6.21, „Implementierung eines Nodes“ automatisch aufgerufen.