Usando o Microsoft .NET no WebSphere Message Broker V8: Parte 2: Integrando ao Microsoft Word

Esta série de quatro tutoriais demonstra o novo suporte para Microsoft .NET no WebSphere Message Broker V8. A parte 2 descreve a integração com o Microsoft Word. 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

Author photoBen 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.



15/Mar/2012

Antes de iniciar

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. Esta série de tutoriais mostra como usar a técnica de integração de nó do .NETCompute.

Sobre esta série de tutoriais

Esta série de quatro tutoriais mostra como gravar e criar código C# no Microsoft Visual Studio 2010 (Express Edition ou Professional Edition) usando modelo integrado fornecido pelo WebSphere Message Broker Toolkit. Os quatro tutoriais exploram os seguintes tópicos:

  1. Usando a amostra de nó do .NETCompute
  2. Usando o nó do .NETCompute para integrar ao Microsoft Word
  3. Usando o nó .NETCompute para integrar ao Microsoft Excel
  4. Usando o nó .NETCompute para manipulação de exceção

Sobre este tutorial

Esta amostra de nó .NETCompute filtra, modifica e transforma mensagens usando o código gravado 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

O código C# neste tutorial pega dados da árvore lógica do Message Broker e os usa para criar um documento do Microsoft Word. O código usa a SDK de Formato XML Aberto (Versão 2), uma API para o .NET Framework que permite a interação dos desenvolvedores em ambientes de cliente e servidor com o Microsoft Word. Antes de começar o tutorial:

  1. Faça download do SDK XML Aberto V2.
  2. Inicie o OpenXMLSDKv2.msi, clique em Next no painel splash e aceite o contrato de licença.
  3. Escolha um local de instalação ou aceite o padrão: C:\Program Files\Open XML SDK\V2.0\.
  4. Confirme as configurações, aguarde a conclusão da instalação e depois clique em Fechar.

Se não tiver uma cópia integral do Microsoft Word, é possível fazer download e instalar o Microsoft Word Viewer e o Microsoft Office Compatibility Pack:

  1. Faça download do Microsoft Word Viewer.
  2. Inicie o wordview_en-us.exe, aceite os termos de licença, clique em Continue, aceite os termos de licença adicionais e depois clique em Next.
  3. Escolha um local de instalação ou aceite o padrão: C:\Program Files\Microsoft Office\.
  4. Aguarde a conclusão da instalação e depois clique em OK duas vezes para sair do instalador.
  5. Faça download do Microsoft Office Compatibility Pack.
  6. Inicie o FileFormatConverter.exe, aceite os termos de licença e clique em Continue.
  7. Aguarde a conclusão da instalação e depois clique em OK.

Introdução

Este tutorial fornece uma definição simples de serviço da web usando um arquivo WSDL que pode ser arrastado e solto em um fluxo de Message Broker a fim de criar uma fachada de serviço da web do Message Broker. Esse fluxo pode ser chamado por um cliente de serviço da web usando SOAP sobre HTTP. A mensagem de solicitação enviada ao fluxo representa uma ordem de venda para vários itens de uma loja.

Após o recebimento dos dados, o fluxo de mensagem usa código C# em um nó do .NETCompute para criar um breve documento do Microsoft Word que contém o detalhe da ordem de venda em uma tabela. O documento Word é gravado em um diretório no sistema de arquivos e depois o fluxo de mensagem envia uma mensagem de reconhecimento de volta ao cliente de serviço da web.


Criando o Fluxo de Mensagem

Faça download do arquivo zip na parte inferior do artigo e extraia o conteúdo no diretório C:\student\DOTNET\lab_msword.

  1. Presumindo que o WebSphere Message Broker Toolkit ainda não tenha sido iniciado, a partir do menu Iniciar, escolha 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 estação de trabalho - o resto deste tutorial presume que esteja usando C:\student\DOTNET\lab_msword\workspace.
  2. Feche a tela de boas vindas e a partir de sua estação de trabalho, ative o assistente Quick Start: clique em Start from WSDL and/or XSD, como mostrado abaixo com a caixa vermelha. Se optar por usar sua própria estação de trabalho existente, será possível ativar o menu Quick Start clicando no link New , na parte superior da visualização Broker Development, à esquerda da janela:

  3. O assistente Quick Start requer um nome de aplicativo para o aplicativo no qual o fluxo de mensagem e a definição de serviço da web serão localizados. Especifique o nome App_DotNet_MSWord e clique em Next:

  4. No painel seguinte, selecione Use external resources e navegue até os artefatos fornecidos no arquivo de download. Se tiver seguido as instruções até agora, você os encontrará no diretório C:\student\DOTNET\lab_msword. Selecione o arquivo Order.wsdl , que contém a definição de serviço da web e depois clique em Next:

  5. No painel Binding Selection final, aceite as configurações padrão, que importarão o OrderSoapHttpBinding (o arquivo WSDL contém apenas uma ligação!). Clique em Finish:

  6. Quando o assistente for concluído, você verá que um novo aplicativo que contém o arquivo WSDL importado e o arquivo de esquema XML ao qual faz referência. Na próxima etapa, você usará o arquivo WSDL para gerar o conteúdo do fluxo de mensagem, conforme descrito pela caixa de pop-up que o Message Broker Toolkit exibe na conclusão do assistente:

  7. O arquivo de fluxo de mensagem MyFlow.msgflow já deve estar aberto no WebSphere Message Broker Toolkit. Arraste o arquivo WSDL Order.wsdl e solte-o na tela do fluxo de mensagem. O assistente Configure New Web Service Usage é aberto. O arquivo WSDL é usado para descrever uma interface com o fluxo e expô-la como um serviço da web. Deixe todas as configurações padrão e clique em Finish:

  8. O Broker Toolkit gera um fluxo de mensagem que foi preenchido com um nó de Entrada SOAP, um nó de Resposta SOAP e um subfluxo chamado Order. O subfluxo extrai o corpo da mensagem do SOAP e a posiciona no domínio de mensagem XMLNSC, antes de retornar para o fluxo principal. Em seu estado atual, o fluxo de mensagem deixa uma brecha entre o subfluxo e o nó de Resposta SOAP. É nessa brecha que você posiciona uma transformação que gera o documento Microsoft Word e também produz uma mensagem de resposta do formato correto, que é passado ao nó de Resposta SOAP para enviar de volta ao cliente de serviço da web:

  9. Posicione um nó do .NETCompute do drawer Transformation da paleta de fluxo no fluxo de mensagem entre o nó Order subflow e o nó SOAPReply. Ligue os terminais do nó como mostrado abaixo:

  10. Clique com o botão direito na pasta nó do .NETCompute e selecione Open Microsoft Visual Studio para ativar o Microsoft Visual Studio, que você usará para desenvolver o código C# que o nó .NETCompute usará para integrar à árvore de mensagem lógica e crie o documento do Microsoft Word:

Você retornará ao fluxo de mensagem uma vez que tiver gravado e criado o código C# no Microsoft Visual Studio.


Gravando o Código C# no Microsoft Visual Studio

As imagens a seguir foram tiradas com o Microsoft Visual Studio Professional Edition, também é possível fazer este tutorial usando o Microsoft Visual Studio Express Edition.

  1. Uma vez que o Microsoft Visual Studio tiver sido ativado, ele exibe a página Iniciar mostrada 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 create a Message Broker message, especifique as propriedades na parte inferior da janela como a seguir e depois clique em OK:

    Name = MSWordDotNetProject
    Location = C:\student\DOTNET\lab_msword\visual studio 2010\Projects
    Solution Name = MSWordDotNetProject

    Se o WebSphere Message Broker Toolkit for instalado após o Microsoft Visual Studio, os modelos de projeto do Message Broker serão automaticamente instalados e estarão prontos para seu uso. Entretanto, se o Broker Toolkit for instalado primeiro, será necessário instalar manualmente os modelos executando o arquivo IBM.Broker.DotNet.vsix e passando pelo assistente. Se tiver usado o local de instalação padrão, encontrará este arquivo em
    C:\Program Files (x86)\IBM\WMBT800\wmbt.

  3. Uma vez criado o projeto, expanda a visualização do Solution Explorer. Você verá que o arquivo CreateNode.cs foi criado para conter a classe C#. Observe também 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. Você também irá interagir com duas montagens adicionais do .NET Framework, uma fornecida pela API do SDK XML Aberto 2.0, e outra que está incluída na estrutura do Windows .NET. Clique com o botão direito no nível References da hierarquia no Solution Explorer e selecione Adicionar referência:

  4. No diálogo Add Reference, alterne para a guia .NET e localize o componente DocumentFormat.OpenXml. Se não puder encontrar a entrada, primeiro certifique-se de classificar os componentes em ordem alfabética. Se a entrada definitivamente não estiver na lista, retorne à seção Requisitos do Sistema acima e siga as instruções para download e instale a API do SDK XML Aberto 2.0. Uma vez que localizar o componente DocumentFormat.OpenXml , clique em OK:

  5. Repita as duas últimas etapas a fim de incluir uma segunda referência ao projeto. Desta vez, localize a referência chamada WindowsBase na guia .NET, como mostrada abaixo e clique em OK:

  6. O Solution Explorer agora deve mostrar que as referências de montagem foram incluídas com sucesso:

  7. O arquivo da classe de modelo CreateNode.cs deve ser aberto e pronto para edição. Na parte superior do arquivo, inclua algumas diretivas de uso para que possa usar as classes e métodos contidos nas referências de montagem que foram recém-incluídas sem ter de qualificá-las no código C#. Esta técnica permite gravar um código mais conciso e mais legível. A imagem abaixo mostra onde inserir as instruções e a listagem a seguir fornece as instruções que devem ser incluídas:

    Lista 1. Usando diretivas a serem posicionadas sobre o CreateNode.cs
    using DocumentFormat.OpenXml;
    using DocumentFormat.OpenXml.Packaging;
    using DocumentFormat.OpenXml.Wordprocessing;
    using SOAP = IBM.Broker.Plugin.NBParsers.SOAP;
  8. Crie dois novos métodos na classe CreateNode , chamados AddParagraph e AddCellToTable. Os métodos serão chamados a partir do método Evaluate (o ponto de entrada para o código C# que é executado pelo nó .NETCompute). Insira esses dois métodos na hierarquia do arquivo de classe CreateNode.cs como irmãos do método CopyMessageHeaders , conforme destacado pela seta vermelha abaixo:

    O código C# é fornecido para os métodos nas duas listagens de código abaixo. A assinatura do método AddParagraph recebe um objeto Corpo e uma cadeia de caractere de texto. A finalidade do método é criar e depois anexar um novo parágrafo no fim do corpo do documento. A cadeia de caractere passada ao método fornece o conteúdo para o parágrafo:

    Lista 2. Código de Amostra para o Método AddParagraph
    private static void AddParagraph(Body body, String wording)
         {
              Paragraph paragraph = new Paragraph();
              Run run = new Run();
              Text text = new Text(wording);
              run.Append(text);
              paragraph. Append(run);
              body.Append(paragraph);
         }

    A assinatura do método AddCellToTable recebe um objeto TableRow e uma cadeia de caractere de texto. A finalidade do método é criar e depois anexar uma nova célula no fim da linha da tabela no documento. A cadeia de caractere passada ao método fornece o conteúdo para a célula:

    Lista 3. Código de Amostra para o Método AddCellToTable
    private static void AddCellToTable(TableRow tableRow, String wording)
         {
              var tableCell = new TableCell();
              tableCell.Append(new Paragraph(new Run(new Text(wording))));
              tableCell.Append(new TableCellProperties(new TableCellWidth()
                   {
                        Type = TableWidthUnitValues.Dxa,
                        Width = "2400"
                   }
              ));
              tableRow.Append(tableCell);
         }

    Em seguida, preencha a região UserCode do método Evaluate . O código para esta seção foi quebrado em quatro listagens separadas abaixo, para que possamos explicar a finalidade de cada seção conforme prosseguirmos.

  9. A finalidade da primeira seção do código no método Evaluate é criar um objeto WordprocessingDocument que representa o conteúdo e a estrutura do arquivo de documento Microsoft Word que será produzido. Um caminho estático é definido para o arquivo de saída em C:\student\DOTNET\lab_msword\Test.docx. O documento que será produzido é uma letra de correspondência. Ele começa com poucas linhas de texto e então cada parágrafo é anexo ao corpo do documento de saída chamando a lógica no método AddParagraph criado anteriormente:
    Lista 4. Primeira seção do código de amostra para a região UserCode do método Evaluate
    #region UserCode
         // Add user code in this region to create a new output message
         string filename = "Test.docx";
         string path = @"C:\student\DOTNET\lab_msword\";
         string srcFile = System.IO.Path.Combine(path, filename);
         WordprocessingDocument wpDoc = 
              WordprocessingDocument.Create(srcFile,WordprocessingDocumentType.Document);
         MainDocumentPart DocPart = wpDoc.AddMainDocumentPart();
         DocPart.Document = new Document();
         Body body = new Body();
         AddParagraph(body, "Dear Sir,");
         AddParagraph(body, "");
         string text = "Thank you very much for your recent correspondence. ";
         text = text + "Your invoice is displayed in the table below:";
         AddParagraph(body, text);
         AddParagraph(body, "");
  10. A segunda seção do código de amostra que está incluído no método Evaluate configura uma tabela no documento. Um objeto Table é criado junto com um objeto TableRow. Sete chamadas do método AddCellToTable são feitas, cada uma inclui uma célula extra com algum texto estático à TableRow. Esta linha é anexa como a primeira linha na tabela. A finalidade deste cabeçalho é manter os nomes de títulos para cada coluna de dados. A próxima seção do código preenche valores de dados nas linhas adicionais da tabela.
    Lista 5. Segunda seção do código de amostra para a região UserCode do método Evaluate
         Table table = new Table();
         var HeaderRow = new TableRow();
         AddCellToTable(HeaderRow, "Code(1)");
         AddCellToTable(HeaderRow, "Code(2)");
         AddCellToTable(HeaderRow, "Code(3)");
         AddCellToTable(HeaderRow, "Description");
         AddCellToTable(HeaderRow, "Category");
         AddCellToTable(HeaderRow, "Price");
         AddCellToTable(HeaderRow, "Quantity");
         table.Append(HeaderRow);
  11. A próxima seção do código C# navega até a seção Invoice da mensagem de entrada e usa a variável Itemlist para manter o conjunto de elementos filhos, que são chamados de Item. Cada iteração do loop inclui uma linha extra à tabela, que contém valores da mensagem de entrada para as propriedades de cada Item, como Código, Descrição e Preço. Uma vez que o loop esteja concluído, a tabela é anexa ao corpo do documento e depois algumas chamadas adicionais do método AddParagraph terminam a letra. Por fim, para esta seção do código, o objeto do corpo é anexo ao documento, que é então salvo e fechado:
    Lista 6. Terceira seção do código de amostra para a região UserCode do método Evaluate
    NBElement Invoice = 
              inputMessage.RootElement["XMLNSC"]["SaleEnvelope"]["SaleList"]["Invoice"];
         var Itemlist = Invoice.Children("Item");
         foreach (NBElement element in Itemlist)
         {
              var NewRow = new TableRow();
              AddCellToTable(NewRow, (string)element["Code", 0]);
              AddCellToTable(NewRow, (string)element["Code", 1]);
              AddCellToTable(NewRow, (string)element["Code", 2]);
              AddCellToTable(NewRow, (string)element["Description"]);
              AddCellToTable(NewRow, (string)element["Category"]);
              AddCellToTable(NewRow, ((decimal)element["Price"]).ToString());
              AddCellToTable(NewRow, (string)element["Quantity"]);
              table.Append(NewRow);
         }
    body.Append(table);
    AddParagraph(body, "");
    AddParagraph(body, "Yours faithfully,");
    AddParagraph(body, "");
    AddParagraph(body, "The WebSphere Message Broker");
    AddParagraph(body, "IBM UK Ltd, Hursley Park, Winchester SO21 2JN, UK.");
    DocPart.Document.Append(body);
    DocPart.Document.Save();
    wpDoc.Close();
  12. A finalidade da seção final do C# na região UserCode é construir a árvore lógica para a mensagem de resposta à qual o fluxo de mensagem acabará retornando ao cliente de serviço da web. A árvore lógica de saída é construída no domínio XMLNSC. O elemento-raiz da árvore XMLNSC é chamado de SaleAcknowledgee este elemento se torna o elemento-raiz do corpo SOAP da mensagem quando é gravado na ligação. O método CreateDoubleNamespaceDeclaration é um método ajudante útil fornecido pela API do WebSphere Message Broker .NET que cria um prefixo de namespace/mapeamento de par na árvore, para que possa criar mensagens que usam sua opção de prefixo ao serializar a saída. A mensagem CreateFirstChild é usada para criar o elemento ResponseMessage que simplesmente contém a cadeia de caractere Message received! para indicar ao cliente de serviço da web que a chamada do fluxo de intermediário foi concluída com sucesso:
    Lista 7. Quarta seção do código de amostra para a região UserCode do método Evaluate
         NBElement soap = outputRoot.CreateLastChildUsingNewParser(SOAP.ParserName);
         string ns = "http://www.acmeorders.com/Order";
         string soapNs = "http://schemas.xmlsoap.org/soap/envelope/";
         NBElement ctx = soap.CreateLastChild("Context").CreateLastChild("Namespace");
         ctx.CreateLastChild(SOAP.DoubleNamespaceDeclaration, 
              "xmlns", "soapenv", soapNs);
         NBElement soapBody = soap.CreateLastChild("Body");
         NBElement saleAck = soapBody.CreateLastChild(ns, "SaleAcknowledge");
         saleAck.CreateLastChild(SOAP.DoubleNamespaceDeclaration, "xmlns", "order", ns);
         saleAck.CreateLastChild(null, "ResponseMessage", "Message received!");
    #endregion UserCode
  13. Com o trabalho do desenvolvimento agora completo, você criará um arquivo de montagem que fará referência ao nó do .NETCompute. No Solution Explorer, clique com o botão direito em A arquitetura e selecione Build Solution:

    Abrindo a janela Saída no Microsoft Visual Studio

    Se a janela Output não estiver visível e estiver usando o Microsoft Visual Studio Professional Edition, será possível abri-la selecionando Debug => Windows => Output. Se a janela Output não estiver visível e estiver usando o Microsoft Visual Studio Express Edition, abra-a selecionando View => Output.

  14. A janela Output mostra o local em seu sistema de arquivos que foi desenvolvido o arquivo de conjunto. Dependendo de como configurou o Microsoft Visual Studio, a janela Build Output pode não estar visível imediatamente.Se não estiver, siga as instruções na barra lateral para abrir a janela Output.

    Se tiver usado a nomenclatura padrão sugerida por todo este tutorial, o arquivo de montagem será salvo em:

    C:\student\DOTNET\lab_msword\visual studio 2010\Projects\MSWordDotNetProject\
    MSWordDotNetProject\bin\Debug\MSWordDotNetProject.dll

A próxima seção do tutorial mostra como unir o desenvolvimento de fluxo de mensagem e a montagem C# que criou e implementar no Message Broker.


Preparação e Implementação no Message Broker

Construído um arquivo de montagem a partir do código C#, é possível arrastar e soltar o arquivo de montagem a partir de uma janela do Windows Explorer diretamente em um nó do .NETCompute em um fluxo de mensagem a fim de associar ao nó com o código. Esta técnica resulta em um local absoluto hard-coded. Esta abordagem economiza tempo ao desenvolver, testar e fazer hot swap do código do .NET que o Broker está executando. Para situações de produção, uma abordagem mais típica é definir um Serviço Configurável do Message Broker que especifica para um nó do .NETCompute onde localizar o arquivo de montagem. Se um Serviço Configurável for usado, ele substituirá um local absoluto hard-coded para a montagem.Aqui está a técnica de arrastar e soltar para a configuração do cenário atual:

  1. Para preparar para arrastar e soltar, retorne ao WebSphere Message Broker Toolkit, onde o fluxo de mensagem MyFlow.msgflow que criou anteriormente ainda deve estar aberto. Abra uma janela do Windows Explorer em frente ao Toolkit e navegue ao local onde criou o arquivo de montagem na seção anterior. Se tiver seguido a nomenclatura padrão até agora, o local será:
    C:\student\DOTNET\lab_msword\visual studio 2010\Projects\MSWordDotNetProject\
    MSWordDotNetProject\bin\Debug\MSWordDotNetProject.dll

    Arraste e solte a montagem sobre o nó do .NETCompute no fluxo, como mostrado pela seta vermelha:



  2. Inspecione as propriedades do nó do .NETCompute e deverá ver que a propriedade do nome Montagem agora foi configurada, como mostrada abaixo. Salve o fluxo de mensagem pressionando Ctrl-S:

  3. Para implementar o aplicativo (que contém o fluxo de mensagem e a definição de serviço da web) criado, basta arrastar e soltá-lo em um grupo de tempo de execução, como a configuração padrão mostrada abaixo. A seta vermelha mostra o movimento de arrastar e soltar:

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. Os dados de teste para o fluxo de mensagem foram salvos em um arquivo cliente de teste de fluxo de mensagem com a extensão de arquivo .mbtest. Este arquivo de dados de teste está incluído no arquivo de download para este artigo. No Message Broker Toolkit, selecione File => Import. No assistente resultante, expanda a seção Geral , destaque File system import como mostrado abaixo e depois clique em Next:

  2. No próximo painel do assistente, navegue até o local em seu sistema de arquivos em que extraiu o arquivo de download. A imagem abaixo presume um local em C:\student\DOTNET\lab_msword. Selecione o arquivo cliente de teste chamado App_DotNet_MSWord.mbtest. Usando o botão Browse , especifique a pasta App_DotNet_MSWord como o destino de importação e depois clique em Finish:

  3. Localize o arquivo importado App_DotNet_MSWord.mbtest no aplicativo App_DotNet_MSWord e clique duas vezes nele para abrir:

  4. Este tutorial presume que já configurou um intermediário de tempo de execução usando a configuração padrão, que fornece um intermediário de mensagem chamado MB8BROKER. Para obter mais informações sobre a configuração padrão, consulte Criando a Configuração Padrão no centro de informações do Message Broker. Se estiver usando uma configuração de tempo de execução diferente, é possível editar o arquivo cliente de teste alternando para a guia Configuração , marcada com a caixa vermelha abaixo:

  5. A mensagem de entrada de teste de amostra fornecida no arquivo cliente de teste é mostrada na listagem abaixo:
    Lista 8. Dados de entrada da mensagem de teste de amostra
    <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/"
                      xmlns:ord="http://www.acmeorders.com/Order">
     <soapenv:Body>
      <ord: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>
        </SaleList>
        <Trailer>
         <CompletionTime>12.00.00</CompletionTime>
        </Trailer>
       </ord:SaleEnvelope>
     </soapenv:Body>
    </soapenv:Envelope>

    Para testar o fluxo de mensagem, clique no botão Send Message como marcado pela caixa vermelha abaixo:

  6. Assim que o teste for executado, você deve ver a mensagem de reconhecimento de saída exibida:


    Veja uma listagem da mensagem de saída:
    Lista 9. Dados de saída da amostra de mensagem SaleEnvelope
    <?xml version="1.0" encoding="utf-8"?>
    <soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
     <soapenv:Body>
      <order:SaleAcknowledge xmlns:order="http://www.acmeorders.com/Order">
       <ResponseMessage>Message received!</ResponseMessage>
      </order:SaleAcknowledge>
     </soapenv:Body>
    </soapenv:Envelope>
  7. Por fim, use a janela do Windows Explorer para navegar até o local de saída do documento Word no sistema de arquivos em C:\student\DOTNET\lab_msword\Test.docx. Abra o documento do Word e deverá ver o conteúdo da fatura exibido na tabela:


Download

DescriçãoNomeTamanho
Code sampledotnet_msword_resources.zip3 KB

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=801811
ArticleTitle=Usando o Microsoft .NET no WebSphere Message Broker V8: Parte 2: Integrando ao Microsoft Word
publish-date=03152012