WebSphere Message Broker, Versão 8.0.0.5 Sistemas operacionais: AIX, HP-Itanium, Linux, Solaris, Windows, z/OS

Consulte as informações sobre a versão mais recente do produto em IBM Integration Bus, Versão 9.0

Estendendo o Recurso de um Processamento de Mensagens ou de Nó Output C

Quando tiver criado um processamento de mensagem definida pelo usuário ou nó de saída em C, você pode estender sua capacidade.

Antes de começar

Leia o tópico Criando um Nó de Processamento de Mensagem ou de Saída em C.

Depois de criar um nó definido pelo usuário, as seguintes opções estarão disponíveis:
  1. Acessando os Dados da Mensagem
  2. Transformando um Objeto Mensagem
  3. Acessando ESQL
  4. Propagando uma Mensagem
  5. Gravando em um Dispositivo de Saída

Acessando os Dados da Mensagem

Em muitos casos, o nó definido pelo usuário precisa acessar o conteúdo da mensagem que é recebida em seu terminal de entrada. A mensagem é representada como uma árvore de elementos de sintaxe. Grupos de funções utilitárias são fornecidos para gerenciamento de mensagens, acesso a buffer de mensagem, navegação de elementos de sintaxe e acesso a elementos de sintaxe. (Consulte Funções de Utilitários de Nó C para obter detalhes sobre as funções de utilitário).

Os tipos de consulta que você provavelmente deseja executar incluem:
  • Obter o elemento raiz do objeto de mensagem requerido
  • Acessando a representação do fluxo de bits de uma árvore de elementos
  • Navegando ou consultando a árvore solicitando pelos elementos filhos ou irmãos pelo nome
  • Obter o tipo do elemento
  • Obter o valor do elemento

Por exemplo, para consultar o nome e o tipo do primeiro filho do corpo:

void cniEvaluate( ...               
){                                    
  ...
/* Navegar até o elemento de destino */ 
  rootElement = cniRootElement(&rc, message);
  bodyElement = cniLastChild(&rc, rootElement);
  bodyFirstChild = cniFirstChild(&rc, bodyElement);

/* Consultar o nome e o valor do elemento de destino */
  cniElementName(&rc, bodyFirstChild, (CciChar*)&elementname, sizeof(elementName)); 
  bytes = cniElementCharacterValue(
		&rc, bodyfirstChild, (CciChar*)&eValue, sizeof(eValue));
  ...    
}

Para acessar a representação de fluxo de bits de uma árvore de elementos, você pode utilizar a função cniElementAsBitstream. Utilizando essa função, é possível obter a representação de fluxo de bits de qualquer elemento em uma mensagem. Consulte cniElementAsBitstream para obter detalhes de como utilizar essa função e o código de amostra.

Transformando um Objeto Mensagem

A mensagem de entrada recebida é de leitura, portanto, antes que uma mensagem possa ser transformada é preciso gravá-la em uma nova mensagem de saída utilizando a função cniCreateMessage. É possível copiar elementos da mensagem de entrada ou criar novos elementos e anexá-los á mensagem. Os novos elementos em geral estão no domínio de um analisador.

Exemplo:
  1. Para gravar a mensagem de entrada para uma nova mensagem:
    {
      ...
      context = cniGetMessageContext(&rc, message)); 
      outMsg = cniCreateMessage(&rc, context)); 
      ...
    }
  2. Para fazer uma cópia da nova mensagem:
    cniCopyElementTree(&rc, sourceElement, targetElement);
  3. Para modificar o valor de um elemento de destino:
      cniSetElementIntegerValue(&rc, targetElement, L"newValue", 8); 
  4. Depois de finalizar e propagar a mensagem é preciso excluir a mensagem de saída utilizando a função cniDeleteMessage:
     cniDeleteMessage(&rc, outMsg);
Como parte da transformação, pode ser necessário criar um novo corpo da mensagem. Para criar um novo corpo da mensagem, utilize uma das seguintes funções, que designam um analisador a uma pasta da árvore de mensagens:
cniCreateElementAsFirstChildUsingParser
cniCreateElementAsLastChildUsingParser
cniCreateElementAfterUsingParser
cniCreateElementBeforeUsingParser
Ao criar um corpo da mensagem, não utilize as seguintes funções porque elas não associam um analisador de propriedade à pasta:
cniCreateElementAsFirstChild
cniCreateElementAsLastChild
cniCreateElementAfter
cniCreateElementBefore

Acessando ESQL

Os nós podem chamar expressões ESQL utilizando sintaxe ESQL de nó Compute. Você pode criar e modificar os componentes da mensagem utilizando as expressões ESQL e pode consultar elementos da mensagem de entrada e dos dados de um banco de dados externo utilizando as funções cniSqlCreateStatement, cniSqlSelect, cniSqlDeleteStatement e cniSqlExecute.

Por exemplo, para ocupar o elemento Result do conteúdo de uma coluna em uma tabela de banco de dados:

{
  ...
  sqlExpr = cniSqlCreateStatement(&rc, 
   (NODE_CONTEXT_ST *)context->nodeObject,
   L"DB", CCI_SQL_TRANSACTION_AUTO,
   L"SET OutputRoot.XMLNS.Result[] = (SELECT T.C1 AS Col1 FROM Database.TABLE AS T;");
  ...
  cniSqlSelect(&rc, sqlExpr, localEnvironment, exceptionList, message, outMsg);
  cniSqlDeleteStatement(&rc, sqlExpr);
  ...                                                               
}

Para obter informações adicionais sobre ESQL, consulte Visão Geral do ESQL.

Se seu nó definido pelo usuário usar primeiramente o ESQL, considere utilizar um Nó Compute.

Propagando uma Mensagem

Antes de propagar uma mensagem, você precisa decidir que dados do fluxo de mensagens deseja propagar, e que terminal deve receber os dados.
  1. Se mensagem foi alterada, finalize-a para que seja propagada, utilizando a função cniFinalize. Exemplo:
          cniFinalize(&rc, outMsg, CCI_FINALIZE_NONE);
  2. O terminalObject é derivado de uma lista que o próprio nó definido pelo usuário mantém. Para propagar a mensagem para o terminal de saída, utilize a função cniPropagate:
      if (terminalObject) {
        if (cniIsTerminalAttached(&rc, terminalObject)) {
          if (rc == CCI_SUCCESS) {
            cniPropagate(&rc, terminalObject, localEnvironment, exceptionList, outMsg);
          }
        }

    No exemplo acima, a função cniIsTerminalAttached é utilizada para testar se a mensagem pode ser propagada para o terminal especificado. Se você não utilizar a função cniIsTerminalAttached e o terminal não estiver anexado a outro nó por um conector, a mensagem não será propagada e nenhuma mensagem de aviso será retornada. Utilize a função cniIsTerminalAttached para impedir que esse erro ocorra.

  3. Se você tiver criado uma nova mensagem de saída utilizando cniCreateMessage, depois de propagar a mensagem, exclua a mensagem de saída utilizando a função cniDeleteMessage:
     cniDeleteMessage(&rc, outMsg);

Gravando em um Dispositivo de Saída

Uma mensagem transformada deve ser serializada para um fluxo de bits; uma mensagem pode ser serializada apenas uma vez.

O fluxo de bits pode então ser acessado e escrito para um dispositivo de saída. Grave a mensagem para um fluxo de bits utilizando a função cniWriteBuffer. Exemplo:
{
  ...
  cniWriteBuffer(&rc, message);
  writeToDevice(cniBufferPointer(&rc, message), cniBufferSize(&rc, message));
  ...                                                               
}
Nesse exemplo, o método writeToDevice é um método escrito pelo usuário que grava um fluxo de bits em um dispositivo de saída.

Não grave um nó de saída definido pelo usuário para gravar mensagens em filas do WebSphere MQ; utilize o nó MQOutput fornecido nesse cenário. O intermediário mantém internamente uma conexão com o WebSphere MQ e a fila aberta é manipulada em uma base encadeamento a encadeamento, e este são armazenados em cache para otimizar o desempenho. Além disso, o intermediário manipula cenários de recuperação quando determinados eventos do WebSphere MQ ocorrem. Isso será afetado de forma adversa se chamadas MQI do WebSphere MQ forem utilizadas em um nó de saída definido pelo usuário.

Avisos | Marcas Registradas | Downloads | Biblioteca | Suporte | Feedback

Copyright IBM Corporation 1999, 2014Copyright IBM Corporation 1999, 2014.

        
        Última atualização:
        
        Última atualização: 2015-02-28 18:30:29


Tópico de TarefaTópico de Tarefa | Versão 8.0.0.5 | as24989_