Usando o Microsoft .NET no WebSphere Message Broker V8: Parte 1: Usando a amostra de nó .NETCompute

Esta série de quatro tutoriais demonstra o novo suporte para Microsoft .NET no WebSphere Message Broker V8. A parte 1 mostra como usar o nó .NETCompute para filtrar, modificar e criar mensagens, além de fornecer uma amostra de cenário com snippets de código C# explicativos. Os leitores devem estar familiarizados com o Microsoft .NET ou com o WebSphere Message Broker, mas não precisam estar familiarizados com ambos.

Matthew Golby-Kirk, Software Developer, IBM

Matthew Golby-Kirk photoMatthew Golby-Kirk é um desenvolvedor de software que trabalha na equipe de desenvolvimento do WebSphere Message Broker no IBM Hursley Software Lab no Reino Unido. Ele trabalha no design e implementação do suporte aos serviços HTTP, web e também com o tempo de execução da linguagem ESQL no WebSphere Message Broker. É possível entrar em contato com Matthew pelo email mgk@uk.ibm.com.



Ben Thompson, Consulting IT Specialist, IBM

Ben Thompson é Consulting IT Specialist e trabalha na equipe de desenvolvimento do WebSphere Message Broker no IBM Hursley Software Lab no Reino Unido. Atualmente, ele trabalha no design e implementação do suporte do .NET no Message Broker. No passado, ele trabalhou para o IBM Software Services for WebSphere desenvolvendo e implementando soluções WebSphere para clientes da IBM no mundo todo. É possível entrar em contato com Ben no email bthomps@uk.ibm.com.



18/Jan/2012

Antes de iniciar

O IBM® WebSphere® Message Broker V8 (que será chamado de Message Broker nesse texto) fornece os recursos para a integração com aplicativos existentes do Microsoft® .NET® Framework (que serão chamados de .NET nesse texto). É possível realizar essa integração conectando o novo nó .NETCompute do Message Broker a um fluxo de mensagens ou chamando um aplicativo .NET a partir de um nó ESQL Compute.

Sobre esta série de tutoriais

Esta série de quatro tutoriais mostra como usar o novo recurso de integração de nó .NETCompute do Message Broker. Cada tutorial mostra como criar um código C# no Microsoft Visual Studio 2010 usando um modelo incorporado, que é fornecido por uma instalação do WebSphere Message Broker Toolkit. Os quatro tutoriais exploram os seguintes tópicos:

  1. Parte 1: Usando a amostra de nó .NETCompute
  2. Parte 2: Integrando ao Microsoft Word
  3. Parte 3: Integrando ao Microsoft Excel
  4. Parte 4: Manipulação de erro e implementação hot swap

Sobre este tutorial

Esta amostra de nó .NETCompute filtra, modifica e transforma mensagens usando o código escrito em C#. É possível usar o nó .NETCompute no Microsoft Windows® brokers para criar mensagens de saída e interagir com os aplicativos Microsoft .NET framework (.NET) ou Component Object Model (COM).

O WebSphere Message Broker permite que você hospede e execute o código .NET em um grupo de execução. O novo nó .NETCompute encaminha ou transforma mensagens usando quaisquer linguagens de programação .NET compatíveis com Common Language Runtime (CLR), como C#, Visual Basic (VB), F# ou C++/Common Language Infrastructure (CLI). Este tutorial descreve a nova API .NET fornecida pelo WebSphere Message Broker, o que permite que os desenvolvedores .NET interajam com a árvore lógica do Message Broker.

Pré-requisitos e requisitos do sistema

Este tutorial é escrito para programadores do WebSphere Message Broker que desejam aprender sobre o novo nó .NETCompute e para programadores .NET que desejam aprender a usar o WebSphere Message Broker. Se você conhecer um pouco o C# ou o Message Broker, talvez você considere o tutorial relativamente fácil de executar.

Para criar e executar o exemplo neste tutorial, será necessário:

  • Uma instalação do Windows que inclui o Microsoft .NET Framework V4
  • O WebSphere Message Broker (Toolkit e Tempo de execução) V8
  • O Microsoft Visual Studio 2010 (Express Edition ou Professional Edition) para escrever e desenvolver o código C# exigido

Arquivos de amostra

É possível importar o fluxo de mensagens e testar os dados deste tutorial a partir da Message Broker Samples Gallery, disponível como parte de sua instalação do Message Broker. Não são necessários outros downloads para completar este tutorial.


Introdução ao tutorial

O fluxo de mensagens do tutorial é importado a partir da Message Broker Samples Gallery. As instruções abaixo explicam como criar o código C# exigido pelo nó .NETCompute e como realizar a implementação e os testes. Este tutorial fornece explicações mais detalhadas para uma amostra da documentação do Message Broker e também usa um serviço de configuração em conjunto com a propriedade AppDomainName do nó .NETCompute para refletir o uso em produção na vida real.

Descrição do cenário

Uma empresa de varejo possui diversas lojas em locais diferentes em uma cidade. As lojas completam as transações de vendas durante todo o dia e cada transação gera uma mensagem XML que é encaminhada a uma fila de entrada em um escritório de TI central:

As lojas estão oferecendo um programa de fidelidade ao cliente. Para cada cliente que se registra no programa de fidelidade, é enviada, para uma mesma fila de entrada, uma mensagem XML em um formato diferente que contém os detalhes pessoais do cliente é enviada. A empresa decidiu usar o Message Broker para processar as mensagens. O encaminhamento e as transformações usadas na solução demonstram os recursos do nó .NETCompute do Message Broker.


Importando o fluxo de mensagens da amostra .NETCompute

  1. Se o Message Broker Toolkit ainda não tiver sido inicializado, selecione Start => Programs => IBM WebSphere Message Broker Toolkit => IBM WebSphere Message Broker Toolkit 8.0 => WebSphere Message Broker Toolkit 8.0. Será solicitado o local de uma área de trabalho -- use C:\student\DOTNET\lab_sample\workspace.
  2. Navegue até a Samples Gallery do WebSphere Message Broker Toolkit no menu Help: selecione Help => Samples and Tutorials => WebSphere Message Broker Toolkit – Message Broker. Quando a página Samples and Tutorials abrir, role a tela até a seção chamada Message Transformation, realçada com a caixa vermelha abaixo. Expanda a seção Message Transformation e clique em .NETCompute Node sample:
  3. Uma janela será aberta e será exibida a introdução da amostra do nó .NETCompute, como mostra abaixo. Leia a página e clique em Import the sample para importar os arquivos de amostra para sua área de trabalho no Broker Toolkit:

  4. O assistente "Prepare the Samples" será iniciado. Clique em Next, aguarde alguns segundos até que os projetos sejam importados, clique em Next novamente e a página final do assistente indicará que a importação foi bem-sucedida. Clique em Finish e você retornará à janela Samples:

  5. Neste ponto, se você já tiver trabalhado com o Message Broker, expanda os menus e explore o restante da amostra por conta própria. Você encontrará os tópicos chamados "Introduction", "Preparing the sample", "Running the sample" e "C# code for the sample" para orientá-lo. Como alternativa, as seções a seguir o orientarão pelo desenvolvimento em C# com mais detalhes.


    A próxima seção do tutorial explora os artefatos importados do Message Broker.

Explorando o fluxo de mensagens

  1. Minimize a janela com a documentação da amostra e retorne ao Message Broker Toolkit. Você verá que a importação criou alguns projetos, como mostra abaixo. Expanda os projetos e você verá que eles contêm diversos arquivos preparados:


    O projeto de aplicativo chamado DotNetApplication contém um único fluxo de mensagens (DotNet.msgflow), dois arquivos com a extensão .mbtest, que são usados para enviar mensagens de teste pelo fluxo de mensagens usando o Broker Test Client integrado e o arquivo Broker Archive (BAR) DotNet.bar, que contém cópias compiladas dos recursos que você implementará no broker de tempo de execução abaixo. Há também um projeto de biblioteca chamado DotNetLibrary que contém as definições de esquema DFDL para um estilo separado por vírgulas da mensagem de saída. Essa biblioteca será usada para uma das ramificações de saída no fluxo de mensagens. Em seguida, examine o fluxo de mensagens DotNet.msgflow, que deve estar aberto:

    • O nó ReadMessages MQInput obtém mensagens de uma fila de entrada chamada DOTNET.IN.
    • O nó Filter de .NETCompute encaminha cada mensagem para uma das duas ramificações de fluxo, dependendo de seu formato.
    • O nó Modify de .NETCompute adiciona alguns elementos XML à mensagem.
    • O nó Create de .NETCompute transforma a mensagem de entrada em uma nova mensagem de saída, que usa um formato separado por vírgula. Ambas as ramificações do fluxo de mensagens resultam na gravação de uma mensagem na mesma fila de saída, chamada DOTNET.OUT.
    • O nó WriteLoyaltyProgramMessage tem o nome da fila de saída de DOTNET.OUT codificado como sua propriedade de nome de fila
    • O nó WriteStoreTransactionMessage tem sua fila de saída controlada dinamicamente usando um DestinationList, que é definido pelo nó Create anterior. A amostra também escolhe definir o DestinationList de modo que ele aponte para a fila DOTNET.OUT.
  2. Examine as propriedades do nó Filter de .NETCompute:
    Ao criar um nó .NETCompute, você o associa a um arquivo de conjunto .Net. Por padrão, o fluxo da amostra foi configurado com o nome de um arquivo de conjunto SampleDotNetProject.dll.
  3. Você criará um Projeto em C#, adicionará o código de origem em C# e o desenvolverá para criar esse arquivo de conjunto em etapas subsequentes. Em seguida retornará à configuração do fluxo de mensagens depois de ter criado esse código de transformação no Microsoft Visual Studio. Clique com o botão direito do mouse em Filter node e selecione Open Microsoft Visual Studio:
    Após a associação de um nó .NETCompute com uma solução específica do Microsoft Visual Studio usando a propriedade Node na guia Visual Studio, ele será iniciado com os arquivos da solução abertos. Ainda é necessário criar a solução .NET, de modo que o Visual Studio abra com sua página de abertura em exibição. A próxima seção explica como escrever o código em C#.

Criando a solução .NET no Microsoft Visual Studio

As imagens a seguir foram tiradas com o Microsoft Visual Studio Professional Edition, mas também é possível usar o Microsoft Visual Studio Express Edition.

  1. Após a inicialização do Microsoft Visual Studio, você verá a Start Page abaixo. Selecione New Project, conforme realçado na caixa vermelha:

  2. O assistente New Project oferece os três tipos de modelos de Projeto. Selecione o chamado Project to route a Message Broker message. Especifique as propriedades na parte inferior da janela e clique em OK:

    Name = SampleDotNetProject
    Location = C:\student\DOTNET\lab_sample\visual studio 2010\Projects
    Solution Name = SampleDotNetProject

  3. Após a criação do projeto, expanda a visualização Solution Explorer na parte superior direita. Você verá que o arquivo FilterNode.cs que foi criado a fim de conter a classe C# e que uma referência a IBM.Broker.Plugin foi adicionada. Esse conjunto contém a API fornecida pelo Message Broker para transformar mensagens em um nó .NETCompute.

  4. Na janela principal, FilterNode.cs foi criado com algumas linhas de código de modelo, que serão adicionadas na próxima etapa. O código é criado dentro de um namespace (realçado abaixo com uma caixa vermelha) que corresponde ao nome do projeto, SampleDotNetProject. O principal ponto de entrada para o código .NET executado em um .NETCompute é o método Evaluate, que contém uma região UserCode que, normalmente, um desenvolvedor de fluxo adiciona seu código. Quando o método Propagate é invocado, o conjunto da mensagem deixa o nó .NETCompute no terminal nomeado. Ao editar esse código na próxima etapa, você irá alterar o método Evaluate para que ele crie um terminal de saída extra e invoque o método Propagate com base em um terminal de saída escolhido, dependendo do conteúdo dos dados da mensagem.

  5. Substitua o conteúdo do método Evaluate no FilterNode.cs (exibido pela caixa vermelha na imagem acima) com o código de amostra fornecido abaixo. Lembre-se de excluir a chamada existente para o método Propagate a partir do modelo gerado na etapa anterior. Essa chamada é a linha de código outTerminal.Propagate(inputAssembly); Além disso, ao fazer a cópia, lembre-se de incluir as definições para os terminais Alternate e Failure, que aparecem nas primeiras linhas do código exibido abaixo:
    Lista 1. Código de amostra para o método Evaluate de FilterNode.cs
    NBOutputTerminal outTerminal = OutputTerminal("Out");
    NBOutputTerminal altTerminal = OutputTerminal("Alternate");
    NBOutputTerminal failureTerminal = OutputTerminal("Failure");
    
    NBMessage inputMessage = inputAssembly.Message;
    NBElement root = inputMessage.RootElement;
    
    #region UserCode
         // Add user code in this region to filter the message
         // The following expression deliberately uses LastChild in
         // preference to FirstChild in case an XML Declaration is present!
         switch(root[NBParsers.XMLNSC.ParserName].LastChild.Name)
         {
              case "LoyaltyProgram":
                   outTerminal.Propagate(inputAssembly);
                   break;
              case "SaleEnvelope":
                   altTerminal.Propagate(inputAssembly);
                   break;
              default:
                   failureTerminal.Propagate(inputAssembly);
                   break;
         }
    #endregion UserCode

    Salve o arquivo editado FilterNode.cs" Pressione Ctrl-S ou use a opção do menu File .
  6. Adicione uma nova classe para modificar uma mensagem do Message Broker a partir do Solution Explorer: clique com o botão direito do mouse em Project na hierarquia (SampleDotNetProject) e selecione Add => Class. Na caixa de diálogo Add New Item resultante, selecione Class to modify a Message Broker message e lembre-se de especificar o nome ModifyNode.cs por padrão, o assistente sugere o nome ModifyNode1.cs). Clique em Add:

  7. Edite o arquivo ModifyNode.cs usando o código abaixo para preencher a região UserCode do modelo:
    Lista 2. Código de amostra para a região UserCode de ModifyNode.cs
    #region UserCode
         NBElement xmlRoot = outputRoot[NBParsers.XMLNSC.ParserName];
         NBElement xmlDecl = xmlRoot[NBParsers.XMLNSC.XmlDeclaration, "XmlDeclaration"];
         if (xmlDecl == null)
         {
              // Create an XML Declaration if required
              NBParsers.XMLNSC.CreateXmlDeclaration(xmlRoot, "1.0", "UTF-8", "yes");
         }
         string notarget = "";
         string ns = "http://www.example.org/store";
         NBElement storeDetails = xmlRoot[notarget,"LoyaltyProgram"][ns, "StoreDetails"];
         string storeName = "";
         string storeStreet = "";
         string storeTown = "Happyville";
         switch ((string)storeDetails[ns, "StoreID"])
         {
              case "001":
                   storeName = "Broker Brothers Central";
                   storeStreet = "Exuberant Avenue";
                   break;
              case "002":
                   storeName = "Broker Brothers Mall";
                   storeStreet = "Enthusiastic Crescent";
                   break;
              case "003":
                   storeName = "Broker Brothers District";
                   storeStreet = "Peaceful Road";
                   break;
         }
         storeDetails.CreateLastChild(ns, "StoreName", storeName);
         storeDetails.CreateLastChild(ns, "StoreStreet", storeStreet);
         storeDetails.CreateLastChild(ns, "StoreTown", storeTown);
    #endregion UserCode

    Salve o arquivo editado ModifyNode.cs" Pressione Ctrl-S ou use a opção do menu File .
  8. Adicione uma nova classe para criar uma mensagem do Message Broker usando o Solution Explorer. Clique com o botão direito do mouse em Project na hierarquia (SampleDotNetProject) e selecione Add => Class. Na caixa de diálogo Add New Item, selecione Class to create a Message Broker message e lembre-se de especificar o nome CreateNode.cs por padrão, o assistente sugere o nome CreateNode1.cs). Clique em Add:

  9. Edite o arquivo CreateNode.cs usando o código abaixo para preencher a região UserCode do modelo:
    Lista 3. Código de amostra para a região UserCode de CreateNode.cs
    #region UserCode
         outputRoot["Properties"]["MessageSet"].SetValue("DotNetLibrary");
         outputRoot["Properties"]["MessageType"].SetValue("File");
         outputRoot.CreateLastChildUsingNewParser(NBParsers.DFDL.ParserName);
         NBElement File =
              outputRoot[NBParsers.DFDL.ParserName].CreateFirstChild(null, "File");
         NBElement inxmlRoot = inputRoot[NBParsers.XMLNSC.ParserName];
         IEnumerable<NBElement> invoices =
              inxmlRoot["SaleEnvelope"]["SaleList"].Children("Invoice");
         foreach (NBElement invoice in invoices)
         {
              TransformInvoice(File, invoice);
         }
         // Define Local Environment override to dynamically control the MQOutput node
         NBElement outLE = outAssembly.LocalEnvironment.RootElement;
         NBElement mqLE =
              outLE.CreateFirstChild(null, "Destination").CreateFirstChild(null, "MQ");
         mqLE = mqLE.CreateFirstChild(null, "DestinationData");
         mqLE.CreateFirstChild(null, "queueName", "DOTNET.OUT");
    #endregion UserCode
  10. Adicione um novo método chamado TransformInvoice ao arquivo CreateNode.cs usando o código fornecido abaixo. Lembre-se de copiá-lo na posição correta no arquivo. Na hierarquia do arquivo, esse método deve ser um irmão do método CopyMessageHeaders.
    Lista 4. Código de amostra para o método TransformInvoice de CreateNode.cs
    private static void TransformInvoice(NBElement outFileEl, NBElement inInvEl)
    {
         // This method creates a structure based on
         // the Invoice Element in the input message
         IEnumerable<NBElement> items = inInvEl.Children("Item");
         foreach (NBElement item in items)
         {
              NBElement record = outFileEl.CreateLastChild(null, "Record");
              string notgt = "";
              record.CreateLastChild(notgt, "Code1", (string)item["Code", 0]);
              record.CreateLastChild(notgt, "Code2", (string)item["Code", 1]);
              record.CreateLastChild(notgt, "Code3", (string)item["Code", 2]);
              record.CreateLastChild(notgt, "Description", (string)item["Description"]);
              record.CreateLastChild(notgt, "Category", (string)item["Category"]);
              record.CreateLastChild(notgt, "Price", (decimal)item["Price"]);
              record.CreateLastChild(notgt, "Quantity", (Int32)item["Quantity"]);
         }
    }

    Deixe o método CopyMessageHeaders (fornecido como parte do modelo durante a adição de CreateNode.cs) sem alterações. Salve o arquivo editado CreateNode.cs: Pressione Ctrl-S ou use a opção do menu File .
  11. No Solution Explorer, clique com o botão direito do mouse na Solution e selecione Build (ou use o atalho F6):

    Como abrir a janela Output no Microsoft Visual Studio

    Se a janela Output não estiver visível e você estiver usando o Microsoft Visual Studio Professional Edition, abra-a usando Debug => Windows => Output. Se a janela Output não estiver visível e você estiver usando o Microsoft Visual Studio Express Edition, abra-a usando View => Output.

  12. A janela Output mostra o local em seu sistema de arquivos que foi desenvolvido o arquivo de conjunto. Dependendo da configuração do Microsoft Visual Studio, talvez a janela Build Output não fique imediatamente visível e, nesse caso, você deverá seguir as instruções na barra lateral da janela Output.

    Se você tiver usado a nomenclatura padrão sugerida durante todo o tutorial, perceberá que o arquivo de conjunto foi salvo em:
    C:\student\DOTNET\lab_sample\visual studio 2010\Projects\SampleDotNetProject\
    SampleDotNetProject\bin\Debug\SampleDotNetProject.dll

A próxima seção do tutorial mostra como unir o desenvolvimento do fluxo de mensagens e o conjunto em C# e implementar no Message Broker.


Implementando no Message Broker

Após desenvolver um arquivo de conjunto a partir do código C#, é possível arrastar e soltar o arquivo de conjunto de uma janela do Windows Explorer diretamente em um nó .NETCompute em um fluxo de mensagens, a fim de associar o nó ao código. Essa técnica resulta em um local absoluto codificado para o conjunto e é útil ao desenvolver, testar e realizar um hot swap do código .NET que o Broker está executando. No entanto, para situações de produção, uma abordagem mais adequada é definir um Message Broker Configurable Service que especifica um nó .NETCompute para localizar o arquivo de conjunto. Esse método é muito mais dinâmico e adequado ao mover uma implementação entre ambientes durante o desenvolvimento, teste e produção. O diagrama abaixo mostra que o mesmo fluxo de mensagens pode ser usado em diversos ambientes, com o serviço configurável em cada ambiente definindo o local do arquivo de conjunto, que pode estar em um local diferente no sistema de arquivos de cada ambiente.

Use essa abordagem e defina um serviço configurável usando as seguintes etapas:

  1. Em uma janela do Windows Explorer, faça uma cópia dos arquivos de conjunto e de depuração, chamados SampleDotNetProject.dll e SampleDotNetProject.pdb:

    Copie os dois arquivos do diretório:
    C:\student\DOTNET\lab_sample\visual studio 2010\Projects\
    SampleDotNetProject\SampleDotNetProject\bin\Debug
    
    Para o diretório:
    C:\student\DOTNET\lab_sample\AssemblyFile
  2. Defina o serviço configurável para o fluxo de mensagens usando o Message Broker Explorer, que é uma interface gráfica com o usuário para administração de seus brokers com base na plataforma Eclipse. O Message Broker Explorer é uma extensão do WebSphere MQ Explorer.

    Abra o Message Broker Explorer e selecione Start => IBM WebSphere Message Broker 8.0.0.0 => Message Broker Explorer. Clique com o botão direito na pasta Configurable Services do broker de tempo de execução que você está usando e selecione New => Configurable Service.

  3. Defina os seguintes parâmetros:

    Name: DotNetAppConfigService
    Type: DotNetDomain
    ApplicationBase: C:\student\DOTNET\lab_sample\AssemblyFile

    Clique em Finish.

  4. Retorne ao WebSphere Message Broker Toolkit e navegue até as propriedades do nó .NETCompute chamado Filter. Alterne para a guia Advanced e defina o nome de AppDomain como DotNetAppConfigService:

  5. Repita a última etapa para os outros dois nós .NETCompute no fluxo de mensagens, chamados Modify e Create. Cada um desses nós usa uma classe definida dentro do mesmo conjunto e cada um dos nós localizará o conjunto no tempo de execução usando o serviço configurável definido acima.
  6. O restante do tutorial presume que você criou um gerenciador de fila chamado MB8QMGR e um broker de tempo de execução chamado MB8BROKER, conhecidos como Default Configuration. Para obter mais informações, consulte Criando a Configuração Padrão no centro de informações do Message Broker.
  7. O fluxo de mensagens exige a criação de duas filas MQ, DOTNET.IN e DOTNET.OUT. Volte ao Message Broker Explorer e clique com o botão direito do mouse na pasta Queues abaixo de seu Gerenciador de filas (na captura de tela abaixo, o gerenciador de filas é chamado MB8QMGR) e escolha New => Local Queue:

  8. Especifique o Name DOTNET.IN e clique em Finish:

  9. Repita as duas últimas etapas para criar uma fila chamada DOTNET.OUT.
  10. Volte ao Message Broker Toolkit e abra o arquivo BAR chamado DotNet.bar, localizado dentro de DotNetApplication. Clique em Rebuild and Save:

  11. Implemente o arquivo BAR, DotNet.bar, arrastando e soltando no grupo de execução:

A próxima seção do tutorial mostra como testar o cenário.


Testando o cenário

Esta seção final do tutorial mostra como testar todo o cenário diretamente do Message Broker Toolkit usando seu Cliente de Teste integrado.

  1. Para testar a ramificação superior do fluxo de mensagens, no DotNetApplication, expanda a pasta Flow Tests e abra o arquivo chamado DotNetApplication_LoyaltyProgram.mbtest. Os dados de entrada contidos no arquivo de teste são exibidos abaixo:
    Lista 5. Dados de entrada da amostra de mensagem LoyaltyProgram
    <LoyaltyProgram
          xmlns:applicant="http://www.example.org/applicant"
          xmlns:store="http://www.example.org/store">
      <applicant:ApplicantDetails>
        <applicant:FirstName>Ben</applicant:FirstName>
        <applicant:LastName>Thompson</applicant:LastName>
        <applicant:HouseNo>1</applicant:HouseNo>
        <applicant:Street>Happiness Avenue</applicant:Street>
        <applicant:Town>Grumpyville</applicant:Town>
      </applicant:ApplicantDetails>
      <store:StoreDetails>
        <store:StoreID>001</store:StoreID>
      </store:StoreDetails>
    </LoyaltyProgram>

    Clique no botão Send Message no canto inferior direito:

  2. Após a execução do teste, verifique se a seção StoreDetails da mensagem possui um StoreName, um StoreStreet e um StoreTown, conforme exibido abaixo na caixa vermelha:


    Veja uma listagem da mensagem de saída:
    Lista 6. Dados de saída da amostra de mensagem LoyaltyProgram
    <?xml version="1.0" encoding="utf-8" standalone="yes"?>
    <LoyaltyProgram
          xmlns:applicant="http://www.example.org/applicant"
          xmlns:store="http://www.example.org/store">
      <applicant:ApplicantDetails>
        <applicant:FirstName>Ben</applicant:FirstName>
        <applicant:LastName>Thompson</applicant:LastName>
        <applicant:HouseNo>1</applicant:HouseNo>
        <applicant:Street>Happiness Avenue</applicant:Street>
        <applicant:Town>Grumpyville</applicant:Town>
      </applicant:ApplicantDetails>
      <store:StoreDetails>
        <store:StoreID>001</store:StoreID>
        <store:StoreName>Broker Brothers Central</store:StoreName>
        <store:StoreStreet>Exuberant Avenue</store:StoreStreet>
        <store:StoreTown>Happyville</store:StoreTown>
      </store:StoreDetails>
    </LoyaltyProgram>
  3. Para testar a ramificação inferior do fluxo de mensagens, no DotNetApplication, expanda a pasta Flow Tests e abra o arquivo DotNetApplication_SaleEnvelope.mbtest. Os dados de entrada contidos no arquivo de teste são exibidos abaixo:
    Lista 7. Dados de entrada da amostra de mensagem SaleEnvelope
    <SaleEnvelope>
     <Header>
      <SaleListCount>1</SaleListCount>
     </Header>
     <SaleList>
      <Invoice>
       <Initial>K</Initial>
       <Initial>A</Initial>
       <Surname>Braithwaite</Surname>
       <Item>
        <Code>00</Code>
        <Code>01</Code>
        <Code>02</Code>
        <Description>Twister</Description>
        <Category>Games</Category>
        <Price>00.30</Price>
        <Quantity>01</Quantity>
       </Item>
       <Item>
        <Code>02</Code>
        <Code>03</Code>
        <Code>01</Code>
        <Description>The Times Newspaper</Description>
        <Category>Books and Media</Category>
        <Price>00.20</Price>
        <Quantity>01</Quantity>
       </Item>
       <Balance>00.50</Balance>
       <Currency>Sterling</Currency>
      </Invoice>
      <Invoice>
       <Initial>T</Initial>
       <Initial>J</Initial>
       <Surname>Dunnwin</Surname>
       <Item>
        <Code>04</Code>
        <Code>05</Code>
        <Code>01</Code>
        <Description>The Origin of Species</Description>
        <Category>Books and Media</Category>
        <Price>22.34</Price>
        <Quantity>02</Quantity>
       </Item>
       <Item>
        <Code>06</Code>
        <Code>07</Code>
        <Code>01</Code>
        <Description>Microscope</Description>
        <Category>Miscellaneous</Category>
        <Price>36.20</Price>
        <Quantity>01</Quantity>
       </Item>
       <Balance>81.84</Balance>
       <Currency>Euros</Currency>
      </Invoice>
     </SaleList>
     <Trailer>
      <CompletionTime>12.00.00</CompletionTime>
     </Trailer>
    </SaleEnvelope>

    Clique no botão Send Message no canto inferior direito:

  4. Após a execução do teste, será exibida a mensagem de saída com um formato separado por vírgula, conforme exibido abaixo na caixa vermelha:


    Veja uma listagem da mensagem de saída:
    Lista 8. Dados de saída da amostra de mensagem SaleEnvelope
    00,01,02,Twister,Games,0.30,1
    02,03,01,The Times Newspaper,Books and Media,0.20,1
    04,05,01,The Origin of Species,Books and Media,22.34,2
    06,07,01,Microscope,Miscellaneous,36.20,1

Recursos

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=WebSphere
ArticleID=785433
ArticleTitle=Usando o Microsoft .NET no WebSphere Message Broker V8: Parte 1: Usando a amostra de nó .NETCompute
publish-date=01182012