Richiamo dei componenti

I componenti con i moduli possono utilizzare i componenti su qualunque nodo di un cluster WebSphere Process Server.

Operazioni preliminari

Prima di richiamare un componente, assicurarsi che il modulo contenente il componente sia installato su WebSphere Process Server.

Perché e quando eseguire questa attività

I componenti possono utilizzare qualunque componente del servizio disponibile all'interno di un cluster di WebSphere Process Server utilizzando il nome del componente e inoltrando il tipo di dati previsto dal componente stesso. Il richiamo di un componente nell'ambiente interessa la posizione e la creazione del riferimento al componente richiesto.
Nota: Un componente in un modulo può richiamare un componente all'interno dello stesso modulo, operazione nota come richiamo intra-modulo. Implementare i richiami esterni (richiami interni del modulo) esportando l'interfaccia nel componente fornito e importando l'interfaccia nel componente di richiamo.
Importante: Durante il richiamo di un componente che si trova su un server diverso da quello su cui è in esecuzione il modulo di richiamo, è necessario eseguire ulteriori configurazioni ai server. Le configurazioni richieste dipendono dal richiamo sincrono o asincrono del componente. Il modo in cui configurare i server delle applicazioni in questo caso, viene descritto nelle attività correlate.

Passi per questa attività

  1. Determinare i componenti richiesti dal modulo di richiamo.

    Prendere nota del nome dell'interfaccia all'interno del componente e del tipo di dati richiesto dall'interfaccia.

  2. Definire un oggetto di dati.

    Sebbene l'input o la restituzione possa essere una classe Java, un oggetto dati del servizio rappresenta la soluzione ottimale.

  3. Ricercare il componente.
    1. Utilizzare la classe ServiceManager per ottenere i riferimenti disponibili al modulo di richiamo.
    2. Utilizzare il metodo locateService() per ricercare il componente.

      In base al componente, l'interfaccia può essere un tipo di porta WSDL (Web Service Descriptor Language) o un'interfaccia Java.

  4. Richiamare il componente in modo sincrono o asincrono.

    È possibile richiamare il componente mediante un'interfaccia Java oppure utilizzando il metodo invoke() per richiamare il componente in modo dinamico.

  5. Elaborare la restituzione.

    Il componente può restituire un'eccezione, pertanto il client deve elaborare questa possibilità.

Esempio del richiamo di un componente

Esempio del richiamo di un componente

L'esempio di seguito riportato crea una classe ServiceManager.
ServiceManager serviceManager = new ServiceManager();
Il seguente esempio utilizza la classe ServiceManager per ottenere un elenco di componenti da un file che contiene i riferimenti del componente.
InputStream myReferences = new FileInputStream("MyReferences.references");
ServiceManager serviceManager = new ServiceManager(myReferences);
Il seguente codice ricerca un componente che implementa l'interfaccia Java StockQuote.
StockQuote stockQuote = (StockQuote)serviceManager.locateService("stockQuote");
Il seguente codice ricerca un componente che implementa un'interfaccia Java o di tipo porta WSDL. Il modulo di richiamo utilizza l'interfaccia Service per interagire con il componente.
Suggerimento: Se il componente implementa un'interfaccia Java, può essere richiamato mediante l'interfaccia o il metodo invoke().
Service stockQuote = (Service)serviceManager.locateService("stockQuote");
L'esempio di seguito riportato illustra MyValue, il codice che richiama un altro componente.
public class MyValueImpl implements MyValue {

	public float myValue throws MyValueException {
		
		ServiceManager serviceManager = new ServiceManager();

	    // variables
	        Customer customer = null;
	        float quote = 0;
	        float value = 0;

	        // invoke
	        CustomerInfo cInfo = 
						(CustomerInfo)serviceManager.locateService("customerInfo");
	        customer = cInfo.getCustomerInfo(customerID);

	    if (customer.getErrorMsg().equals("")) {

	        // invoke
	    		StockQuoteAsync sQuote = 
						(StockQuoteAsync)serviceManager.locateService("stockQuote");
	    		Ticket ticket =  sQuote.getQuoteAsync(customer.getSymbol());
				// … do something else …
	    		quote =  sQuote.getQuoteResponse(ticket, Service.WAIT);

	        // assign
	        	value = quote * customer.getNumShares();
} else {

	        // throw
	       	throw new MyValueException(customer.getErrorMsg()); 
	    }
	    // reply
	        return value;
	}
}

Operazioni successive

Configurare i collegamenti tra i riferimenti del modulo di richiamo e le interfacce del componente.

Richiamo dinamico di un componente

Quando un modulo richiama un componente che dispone di un'interfaccia di tipo porta WSDL (Web Service Descriptor Language), il modulo deve richiamare il componente in modo dinamico utilizzando il metodo invoke().

Operazioni preliminari

Questa attività presuppone che un componente chiamante stia richiamando un componente in modo dinamico.

Perché e quando eseguire questa attività

Con un'interfaccia di tipo porta WSDL, un componente chiamante deve utilizzare il metodo invoke() per richiamare il componente. Inoltre, un modulo di richiamo può richiamare un componente che dispone di un'interfaccia Java.

Passi per questa attività

  1. Determinare il modulo che contiene il componente richiesto.
  2. Determinare la matrice richiesta dal componente.
    La matrice di input può essere di uno dei tre tipi che seguono:
    • Tipi Java in maiuscolo primitivi o matrici di questo tipo
    • Classi Java ordinarie o matrici delle classi
    • SDO (Service Data Objects)
  3. Definire una matrice per contenere la risposta dal componente.

    La matrice di risposta può essere dello stesso tipo della matrice di input.

  4. Utilizzare il metodo invoke() per richiamare il componente richiesto e inoltrare l'oggetto della matrice al componente.
  5. Elaborare il risultato.

Esempi di richiamo dinamico di un componente

Esempi di richiamo dinamico di un componente

Nel seguente esempio, un modulo utilizza il metodo invoke() per richiamare un componente che utilizza tipi di dati Java di lettere maiuscole di origine.
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);

L'esempio di seguito riportato utilizza il metodo invoke con un'interfaccia di tipo porta WSDL come destinazione.

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 racchiude tutti i parametri di methodOne
			wrapBo.set("input2", "XXXX");
			wrapBo.set("input3", "yyyy");

	DataObject resBo= (DataObject)serviceOne.invoke("methodOne", wrapBo);

(c) Copyright IBM Corporation 2005, 2006.
Questo Infocenter è alimentato dalla tecnologia Eclipse (http://www.eclipse.org)