Invocación de componentes

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

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

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

  3. Localice el componente.
    1. Utilice la clase ServiceManager para obtener las referencias disponibles en el módulo llamante.
    2. 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.

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

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

  1. Determine el módulo que contiene el componente necesario.
  2. 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)
  3. 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.

  4. Utilice el método invoke() para invocar el componente necesario y pasar el objeto de matriz al componente.
  5. 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);

Condiciones de uso |


(c) Copyright IBM Corporation 2005, 2006.
Este centro de información está basado en tecnología Eclipse (http://www.eclipse.org)