Richiamo dei componenti

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

Prima di richiamare un componente, assicurarsi che il modulo contenente il componente sia installato su WebSphere Process Server.
I componenti possono utilizzare qualunque componente del servizio disponibile all'interno di WebSphere Process Server cluster 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 dell'applicazione in questo caso, viene descritto nelle attività correlate.
  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.

    E' possibile richiamare il componente mediante un'interfaccia Java oppure utilizzare 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

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 del tipo di 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;
	}
}
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 del tipo d porta WSDL (Web Service Descriptor Language), il modulo deve richiamare il componente in modo dinamico utilizzando il metodo invoke().

Questa attività presuppone che un componente chiamante stia richiamando un componente in modo dinamico.
Con un'interfaccia del tipo di 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.
  1. Determinare il modulo che contiene il componente richiesto.
  2. Determinare la matrice richiesta dal componente.
    La matrice di input può essere una dei tre tipi:
    • Lettere maiuscole di origine di tipi Java 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

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 del tipo di 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 encapsulates all the parameters of methodOne
			wrapBo.set("input2", "XXXX");
			wrapBo.set("input3", "yyyy");

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

Terms of use |

Last updated: Thu Apr 06 14:28:02 2006

(c) Copyright IBM Corporation 2005, 2006.
This information center is powered by Eclipse technology (http://www.eclipse.org)