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

Antes de começar

Certifique-se de que tenha lido e entendido o seguinte tópico:
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 necessita 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 de 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 código de amostra.

Transformando um Objeto Mensagem

A mensagem de entrada recebida é somente leitura, portanto antes que uma mensagem possa ser transformada é preciso gravá-la para 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, as seguintes funções estão disponíveis:
cniCreateElementAsFirstChildUsingParser
cniCreateElementAsLastChildUsingParser
cniCreateElementAfterUsingParser
cniCreateElementBeforeUsingParser
Estas funções devem ser utilizadas, porque são específicas para designação de um analisador a uma pasta da árvore de mensagens.
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. É possível criar e modificar os componentes da mensagem utilizando as expressões ESQL e referir-se a elementos da mensagem de entrada e aos 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.XML.Result[] = (SELECT T.C1 AS Col1 FROM Database.TABLE AS T;");
  ...
    cniSqlSelect(&rc, sqlExpr, destinationList, 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, consulte 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, ela deve ser finalizada antes de ser 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, destinationList, 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 evitar que isso ocorra.

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

Gravando em um Dispositivo de Saída

Uma mensagem transformada precisa ser serializada para um fluxo de bits. 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 para um dispositivo de saída.

Observe que uma mensagem pode ser serializada somente uma vez.

Nota: É preciso utilizar o nó MQOutput fornecido ao gravar para filas do WebSphere MQ, porque o intermediário mantém internamente uma conexão ao WebSphere MQ e o identificador de filas aberto em uma base encadeamento a encadeamento, e estes são armazenados em cache para otimizar o desempenho. Além disso, o intermediário manipula cenários de recuperação quando determinados eventos WebSphere MQ ocorrem e isso seria afetado de forma adversa se chamadas WebSphere MQ MQI fossem utilizadas em um nó output definido pelo usuário.
Avisos | Marcas Registradas | Downloads | Biblioteca | Suporte | Feedback
Direitos Autorais IBM Corporation 1999, 2006 Última Atualização: 1 Sep 2006
as24989_