Komponenten mit Modulen können Komponenten auf jedem beliebigen Knoten eines WebSphere Process Server-Clusters verwenden.
Vergewissern Sie sich vor dem Aufrufen einer Komponente, dass das Modul, in dem die
Komponente enthalten ist, auf WebSphere Process Server
installiert ist.
Komponenten können jede beliebige in einem
WebSphere Process Server-Cluster
verfügbare Servicekomponente verwenden, wenn der Name der Komponente verwendet und der von der Komponente
erwartete Datentyp übergeben wird. Zum Aufrufen einer Komponente in dieser Umgebung
muss die erforderliche Komponente lokalisiert und anschließend die Referenz auf die erforderliche Komponente
erstellt werden.
Anmerkung: Eine Komponente in einem Modul
kann eine Komponente in demselben Modul aufrufen; dies wird auch Intramodulaufruf genannt.
Exportieren Sie zum Implementieren von externen Aufrufen (modulübergreifende
Aufrufe) die Schnittstelle in die bereitstellende Komponente, und importieren
Sie die Schnittstelle in die aufrufende Komponente.
Wichtig: Wenn Sie eine Komponente aufrufen, die sich auf einem anderen Server
als dem befindet, auf dem das aufrufende Modul ausgeführt wird,
müssen Sie weitere Konfigurationen für die Server
durchführen. Die erforderlichen Konfigurationen sind davon abhängig, ob
die Komponente asynchron oder synchron aufgerufen wird. Die Vorgehensweise zum Konfigurieren der Anwendungsserver in diesem Fall wird in den zugehörigen Tasks
beschrieben.
- Stellen Sie fest, welche Komponenten für das aufrufende Modul erforderlich sind.
Notieren Sie den Namen der Schnittstelle innerhalb einer Komponente und den für die
Schnittstelle erforderlichen Datentyp.
- Definieren Sie ein Datenobjekt.
Die Eingabe oder
Rückgabe kann auch aus einer Java-Klasse bestehen, aber ein Servicedatenobjekt ist
dafür am besten geeignet.
- Lokalisieren Sie die Komponente.
- Verwenden Sie die Klasse ServiceManager, um die
für das aufrufende Modul verfügbaren Verweise zu ermitteln.
- Verwenden Sie die Methode locateService(), um die Komponente zu finden.
Je nach Komponente kann die Schnittstelle einen WSDL-Porttyp (WSDL = Web Service
Descriptor Language) aufweisen oder eine Java-Schnittstelle sein.
- Rufen Sie die Komponente synchron oder asynchron auf.
Sie können die Komponente über eine Java-Schnittstelle
aufrufen oder dynamisch mit der Methode invoke().
- Verarbeiten der Rückgabedaten.
Möglicherweise generiert die
Komponente eine Ausnahmebedingung, d. h. der Client muss diese Situation verarbeiten
können.
Beispiel für das Aufrufen einer Komponente
Das folgende Beispiel erstellt
eine Klasse
ServiceManager.
ServiceManager serviceManager = new ServiceManager();
Im
folgenden Beispiel wird die Klasse
ServiceManager verwendet, um eine
Liste der Komponenten aus einer Datei abzurufen, die die Komponentenverweise enthält.
InputStream myReferences = new FileInputStream("MyReferences.references");
ServiceManager serviceManager = new ServiceManager(myReferences);
Der folgende
Code lokalisiert eine Komponente, von der die Java-Schnittstelle StockQuote
implementiert wird.
StockQuote stockQuote = (StockQuote)serviceManager.locateService("stockQuote");
Der folgende Code lokalisiert eine Komponente, von der eine Java-Schnittstelle
oder eine WSDL-Porttypschnittstelle implementiert wird. Das aufrufende Modul
verwendet die Schnittstelle
Service für Interaktionen
mit der Komponente.
Tipp: Wenn die Komponente eine
Java-Schnittstelle
implementiert, kann sie über die Schnittstelle oder mit der Methode invoke() aufgerufen
werden.
Service stockQuote = (Service)serviceManager.locateService("stockQuote");
Das folgende Beispiel zeigt den Code für MyValue, der eine andere Komponente aufruft.
public class MyValueImpl implements MyValue {
public float myValue throws MyValueException {
ServiceManager serviceManager = new ServiceManager();
// Variablen
Customer customer = null;
float quote = 0;
float value = 0;
// Aufrufen
CustomerInfo cInfo = (CustomerInfo)serviceManager.locateService("customerInfo");
customer = cInfo.getCustomerInfo(customerID);
if (customer.getErrorMsg().equals("")) {
// Aufrufen
StockQuoteAsync sQuote =
(StockQuoteAsync)serviceManager.locateService("stockQuote");
Ticket ticket = sQuote.getQuoteAsync(customer.getSymbol());
// … Andere Aktion ausführen …
quote = sQuote.getQuoteResponse(ticket, Service.WAIT);
// Zuordnen
value = quote * customer.getNumShares();
} else {
// Auslösen
throw new MyValueException(customer.getErrorMsg());
}
// Antwort
return value;
}
}
Konfigurieren Sie die Verbindungen zwischen den Verweisen des aufrufenden
Moduls und den Komponentenschnittstellen.
Komponente dynamisch aufrufen
Wenn ein Modul eine Komponente aufruft, die über eine WSDL-Porttypschnittstelle
(WSDL = Web Service Descriptor Language) verfügt, muss die Komponente dynamisch mit
der Methode invoke() aufgerufen werden.
Bei dieser Task wird vorausgesetzt, dass eine aufrufende Komponente eine
andere Komponente dynamisch aufruft.
Bei einer WSDL-Porttypschnittstelle muss eine aufrufende Komponente
die Methode invoke() verwenden, um die gewünschte Komponente aufzurufen. Ein aufrufendes Modul kann auf diese Weise auch eine Komponente aufrufen, die
über eine Java-Schnittstelle verfügt.
- Stellen Sie fest, welches Modul die erforderliche Komponente enthält.
- Stellen Sie fest, welche Matrix für die Komponente erforderlich ist.
Drei
Typen von Eingabematrix kommen in Frage:
- Primitive Java-Typen oder -Arrays in Großschreibung
- Gewöhnliche Java-Klassen oder Arrays der Klassen
- Servicedatenobjekte (SDOs)
- Definieren Sie eine Matrix für die Antwort der Komponente.
Die Antwortmatrix kann vom gleichen Typ sein wie die Eingabematrix.
- Rufen Sie die erforderliche Komponente mit der Methode invoke() auf, und
übergeben Sie das Matrixobjekt an die Komponente.
- Verarbeiten Sie das Ergebnis.
Beispiele für das dynamische Aufrufen einer Komponente
Im folgenden
Beispiel ruft ein Modul mit der Methode invoke() eine Komponente auf, die Primitive
Java-Datentypen in Großschreibung verwendet.
Service service = (Service)serviceManager.locateService("multiParamInf");
Reference reference = service.getReference();
OperationType methodMultiType =
reference.getOperationType("methodWithMultiParameter");
Type t = methodMultiType.getInputType();
BOFactory boFactory = (BOFactory)serviceManager.locateService
("com/ibm/websphere/bo/BOFactory");
DataObject paramObject = boFactory.createbyType(t);
paramObject.set(0,"input1")
paramObject.set(1,"input2")
paramObject.set(2,"input3")
service.invoke("methodMultiParamater",paramObject);
Im folgenden Beispiel wird die
Methode invoke mit einer WSDL-Porttypschnittstelle als Ziel aufgerufen.
Service serviceOne = (Service)serviceManager.locateService("multiParamInfWSDL");
DataObject dob = factory.create("http://MultiCallWSServerOne/bos", "SameBO");
dob.setString("attribute1", stringArg);
DataObject wrapBo = factory.createByElement
("http://MultiCallWSServerOne/wsdl/ServerOneInf", "methodOne");
wrapBo.set("input1", dob); //wrapBo kapselt alle Parameter von methodOne
wrapBo.set("input2", "XXXX");
wrapBo.set("input3", "yyyy");
DataObject resBo= (DataObject)serviceOne.invoke("methodOne", wrapBo);