Komponenten aufrufen

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.
  1. 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.

  2. 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.

  3. Lokalisieren Sie die Komponente.
    1. Verwenden Sie die Klasse ServiceManager, um die für das aufrufende Modul verfügbaren Verweise zu ermitteln.
    2. 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.

  4. Rufen Sie die Komponente synchron oder asynchron auf.

    Sie können die Komponente über eine Java-Schnittstelle aufrufen oder dynamisch mit der Methode invoke().

  5. 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.
  1. Stellen Sie fest, welches Modul die erforderliche Komponente enthält.
  2. 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)
  3. Definieren Sie eine Matrix für die Antwort der Komponente.

    Die Antwortmatrix kann vom gleichen Typ sein wie die Eingabematrix.

  4. Rufen Sie die erforderliche Komponente mit der Methode invoke() auf, und übergeben Sie das Matrixobjekt an die Komponente.
  5. 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);

(c) Copyright IBM Corporation 2005, 2006.
Dieses Information Center basiert auf Eclipse-Technologie. (http://www.eclipse.org)