Los componentes con módulos pueden utilizar componentes en cualquier
nodo de un clúster de WebSphere Process Server.
Antes de empezar
Antes de invocar un componente, asegúrese de que el módulo que contiene
el componente esté instalado en WebSphere Process Server.
Por qué y cuándo realizar esta tarea
Los componentes pueden utilizar cualquier componente de servicio
disponible en un clúster de
WebSphere Process Server utilizando el
nombre del componente y pasando el tipo de datos que espera el componente.
La invocación de un componente en este entorno implica
localizar y, a continuación, crear la referencia en el componente
necesario.
Nota: Un componente de un módulo puede invocar un componente en el mismo
módulo, conocido como una invocación dentro del módulo.
Implemente llamadas externas (invocaciones intermódulos) exportando la interfaz
del componente que se proporciona e importando la interfaz en el componente
llamante.
Importante: Cuando se invoca un componente que reside en un servidor
distinto de aquél donde se ejecuta el módulo llamante, debe realizar
configuraciones adicionales en los servidores.
Las configuraciones necesarias dependen de si se llama al componente de forma
asíncrona o síncrona.
La manera de configurar los servidores de aplicaciones en este caso se
describen en tareas relacionadas.
Pasos para realizar esta tarea
- Determine los componentes que necesita el módulo llamante.
Tome nota del nombre de la interfaz dentro de un componente
y el tipo de datos que la interfaz necesita.
- Defina un objeto de datos.
Aunque la entrada o el
retorno puede ser una clase Java, lo óptimo es un objeto de datos de servicio.
- Localice el componente.
- Utilice la clase ServiceManager para obtener
las referencias disponibles en el módulo llamante.
- Utilice el método locateService() para encontrar el componente.
Según el componente, la interfaz puede ser un tipo de puerto WSDL (Web
Service Descriptor Language) o una interfaz
Java.
- Invoque el componente de manera síncrona o asíncrona.
Puede invocar el componente mediante una interfaz
Java
o utilice el método invoke() para invocar el componente de manera
dinámica.
- Procese la devolución.
El componente puede generar una
excepción, de manera que el cliente tiene que poder procesar esa posibilidad.
Ejemplos de invocación de un componente
En el ejemplo siguiente se
crea una clase
ServiceManager.
ServiceManager serviceManager = new ServiceManager();
El
ejemplo siguiente utiliza la clase
ServiceManager para
obtener una lista de componentes de un archivo que contenga las referencias de
componente.
InputStream myReferences = new FileInputStream("MyReferences.references");
ServiceManager serviceManager = new ServiceManager(myReferences);
El código siguiente localiza un componente que implementa la
interfaz StockQuote
Java.
StockQuote stockQuote = (StockQuote)serviceManager.locateService("stockQuote");
El código siguiente localiza un componente que implementa una interfaz
de tipo de puerto Java
o WSDL. El módulo llamante utiliza la interfaz
Service
para interactuar con el componente.
Consejo: Si el componente implementa una interfaz
Java,
el componente puede invocarse utilizando la interfaz o el método invoke().
Service stockQuote = (Service)serviceManager.locateService("stockQuote");
En el ejemplo siguiente se muestra MyValue, código que llama a otro 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;
// invocar
CustomerInfo cInfo =
(CustomerInfo)serviceManager.locateService("customerInfo");
customer = cInfo.getCustomerInfo(customerID);
if (customer.getErrorMsg().equals("")) {
// invocar
StockQuoteAsync sQuote =
(StockQuoteAsync)serviceManager.locateService("stockQuote");
Ticket ticket = sQuote.getQuoteAsync(customer.getSymbol());
// … hacer otra cosa…
quote = sQuote.getQuoteResponse(ticket, Service.WAIT);
// asignar
value = quote * customer.getNumShares();
} else {
// lanzar
throw new MyValueException(customer.getErrorMsg());
}
// responder
return value;
}
}
Qué hay que hacer a continuación
Configure los cables entre las referencias al módulo llamante y las
interfaces de componente.
Invocación dinámica de un componente
Cuando un módulo invoca un componente que tiene una interfaz de tipo
de puerto WSDL (Service Descriptor Language), el módulo debe invocar el
componente de forma dinámica utilizando el método invoke().
Antes de empezar
En esta tarea se da por supuesto que un componente llamante invoca a un
componente de forma dinámica.
Por qué y cuándo realizar esta tarea
Con una interfaz de tipo de puerto WSDL, un componente llamante debe
utilizar el método invoke() para invocar el componente.
Un módulo llamante también puede invocar un componente que tiene una interfaz
Java
de esta manera.
Pasos para realizar esta tarea
- Determine el módulo que contiene el componente necesario.
- Determine la matriz que el componente necesita.
La
matriz de entrada puede ser de uno de los tres tipos siguientes:
- Tipos o matrices
Java
primitivos en mayúsculas de este tipo
- Clases o matrices
Java
de las clases
- SDO (Service Data Objects)
- Defina una matriz para que contenga la respuesta del componente.
La matriz de respuesta puede ser de los mismos tipos que la matriz de
entrada.
- Utilice el método invoke() para invocar el componente necesario y
pasar el objeto de matriz al componente.
- Procese el resultado.
Ejemplos de invocación dinámica de un componente
En
el ejemplo siguiente, un módulo utiliza el método invoke() para llamar a un
componente que utiliza tipos de datos
Java primitivos en mayúsculas.
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);
En el ejemplo
siguiente se utiliza el método invoke con una interfaz de tipo de puerto WSDL de destino.
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 encapsula todos los parámetros de methodOne
wrapBo.set("input2", "XXXX");
wrapBo.set("input3", "yyyy");
DataObject resBo= (DataObject)serviceOne.invoke("methodOne", wrapBo);