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à
- 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.
- 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.
- Ricercare il componente.
- Utilizzare la classe ServiceManager per ottenere i riferimenti disponibili al modulo di richiamo.
- 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.
- 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.
- 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à
- Determinare il modulo che contiene il componente richiesto.
- 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)
- Definire una matrice per contenere la risposta dal componente.
La matrice di risposta può essere dello stesso tipo della matrice di input.
- Utilizzare il metodo invoke() per richiamare il componente richiesto e inoltrare l'oggetto della matrice al componente.
- 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);