Cliente WebService – Delphi7 & Servidor Webservice BDS2006

Continuando, sobre WebServices, construiremos o cliente que consumirá o serviço que criamos no artigo “Webservice no BDS2006”.
No Delphi 7 inicie um novo projeto: Menu File ► New ► Application. Em seguida vou adicionar um TButton, um TlistBox no Form1.

Importando a WSDL

Próximo passo, importar a interface do serviço. Para isso, no browser digite a url para acessarmos o WebService. Usaremos o serviço contruido no artigo anterior, portanto digite na barra de endereços do browser: http://localhost/wsshowmethemoneyzn/
Click no link “IZnShowMeTheMoney [WSDL]”, a página que será exibida é o XML que define as especificações da interface do serviso “ZnShowMeTheMoney”. Salve esta página.

Voltando ao Delphi, no menu Menu File ► New ► Other, na aba WebServices selecione “WSDL Importer”.

Selecione o arquivo que acabamos de salvar, o arquivo XML que especifica a interface do serviço: “IZnShowMeTheMoney.xml”.

Em seguida click em “Next”, Tchan ... Tchan ... Tchammm ..!!!! Você acabou de importar a WSDL para sua aplicação cliente. Pode ficar emocionado amigo, agora você faz parte de um seleto grupo de indivíduos que ultrapassaram a fronteira do B2C (Businesses to Consumer) para o B2B (Businesses to Businesses). Parabéns! Em seguida, ao clicar em “Finish”, prosseguiremos salvando a nova unit, resultante da importação que acabamos de fazer, IZnShowMeTheMoney1.pas. Então, codificaremos a funcionalidade que evocará o serviço “IznShowMeTheMoney”.

Na unit1 farei uses da unit “IZnShowMeTheMoney1.pas”, Alt + F11. Falta ainda adicionar um THTTPRio (Palheta WebServices)

Na propriedade URL do HTTPRIO1 digite a url da interface, WSDL, do serviço “IznShowMeTheMoney” trocando o “/wsdl” para “/soap”. Exemplo: http://localhost/wsshowmethemoneyzn/PrjZNShowMoney.dll/soap/IZnShowMeTheMoney

No evento “OnClick” do Button1 digite conforme iluistrado abaixo:

procedure TForm1.Button1Click(Sender: TObject);
begin
 ListBox1.Items.Add((HTTPRIO1 as IZnShowMeTheMoney).ZnShowMeTheMoney);
end;

Asseguir código completo da Unit1:

unit Unit1;

interface

uses
 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
 Dialogs, StdCtrls, InvokeRegistry, Rio, SOAPHTTPClient;

type
 TForm1 = class(TForm)
   Button1: TButton;
   ListBox1: TListBox;
   HTTPRIO1: THTTPRIO;
   procedure Button1Click(Sender: TObject);
 private
   { Private declarations }
 public
   { Public declarations }
 end;

var
 Form1: TForm1;

implementation

uses IZnShowMeTheMoney1, Math;

{$R *.dfm}


procedure TForm1.Button1Click(Sender: TObject);
begin
 ListBox1.Items.Add((HTTPRIO1 as IZnShowMeTheMoney).ZnShowMeTheMoney);
end;

end.

Conclusões

Para consumir um WebService é preciso importar a interface so serviço para o programa cliente.
O Fato de usar um WebService não garante a interoperabilidade entre dois sistemas. É muito importante garantir que o tipo de dado da saída do seu serviço seja suportado pela tecnologia usada pelo cliente.
No nosso exemplo pudemos observar que um servidor Werbservice construido em BDS2006 pode ser consumido por um cliente desenvolvido em Delphi 7. O que já era de se esperar, contudo este pequeno exemplo não pode garantir que isso é válido para qualquer outro caso.

Artigo completo (View Full Post)

Webservice no BDS2006

Observamos que o assunto "WebService em Delphi" tem tido muita procura aqui no blog. Por isso, pretendo produzir mais material sobre este tema. Contudo, o assunto é abrange um escopo bastante vasto, principalmente no que tange as questões práticas do desenvolvimento de serviços baseados em XML/SOAP. Podemos citar para exemplificar alguns temas sobre “WebService e Delphi”: Testar as versões mais recentes (inclusive o Tiburon – Delphi 2009), verificar incompatibilidades (se existirem), ou diferenças. Uma coisa interessante seria a integração com outras tecnologias (Java, C# e PHP, por exemplo). Outro ponto importante: Acesso e disponibilização de dados (um CRUD, talvez, usando como camada intermediária um aplicação servidora WS). Em fim, há bastante terreno para ser trabalhado.
Neste sentido, podemos eventualmente atender alguma questão pontual demandada pelos leitores. Coloque em forma de comentários sua demanda que na medida do possível teremos prazer em atendê-la. Algumas pessoas já solicitam nosso suporte, informalmente, via e-mail. Porém, seria melhor que além do e-mail o comentário sobre a demanda fosse registrado. Pois, dessa forma aproveitamos a resolução do seu problema para conteúdo do blog. Assim, outros que por ventura vierem até nós com problemas semelhantes possam compartilhar da solução sem gerar retrabalho para nós. Conseqüentemente, imagino que nosso conteúdo será mais aderente. Isso é o que de fato nos importa.

Iniciando um novo projeto

No BDS2006 no menu File ►New ► Other ► Delphi Projects ►WebServices, selecione “SOAP Server Application”. Em seguida uma série de configurações prévias serão feitas mediante alguns diálogos.

No diálogo seguinte selecione ISAPI/NSAPI Dynamic Link Library, e click em “OK”.



Click “Yes” para criar a interface do serviço (WSDL). Veja imagem abaixo:

No próximo diálogo definiremos o nome do serviço que estamos criando: “ZnShowMeTheMoney”, conforme ilustrado abaixo.

Pronto, temos um novo projeto! Estamos desenvolvendo uma aplicação servidora. Um WebService, veja as units que foram cridas na inicialização do nosso projeto:

A lógica sobre declarações nas units, num projeto WebService: Existe uma unit para declarações de interface e uma unit para as implementarmos o que declararemos na unit interface (neste caso temos: “ZnShowMeTheMoneyIntf”, interface. “ZnShowMeTheMoneyImpl”, implementação).

Na interface declararemos uma função. Digite conforme ilustrado abaixo:

  (* Declarando uma funcionalidade no serviço que estamos criando *)
  function ZnShowMeTheMoney: WideString; stdcall;

A seguir, veja como ficou a unit “ZnShowMeTheMoneyIntf”.

{ Invokable interface IZnShowMeTheMoney }

unit ZnShowMeTheMoneyIntf;

interface

uses InvokeRegistry, Types, XSBuiltIns;

type

  { Invokable interfaces must derive from IInvokable }
  IZnShowMeTheMoney = interface(IInvokable)
  ['{F002F904-9FD7-401D-80E2-037DFFAA4590}']

  { Methods of Invokable interface must not use the default }
  { calling convention; stdcall is recommended }
  (* Declarando uma funcionalidade no serviço que estamos criando *)
  function ZnShowMeTheMoney: WideString; stdcall;
end;

implementation

initialization
  { Invokable interfaces must be registered }
   InvRegistry.RegisterInterface(TypeInfo(IZnShowMeTheMoney));

end.

Agora para implementarmos iremos fazê-lo na unit “ZnShowMeTheMoneyImpl”. Digite conforme ilustrado no trecho de código asseguir:

type

  { TZnShowMeTheMoney }
  TZnShowMeTheMoney = class(TInvokableClass, IZnShowMeTheMoney)
  public
   (* Na unit de implementação precisamos digitar novamente a assinatura do
      método que declaramos na interface "ZnShowMeTheMoneyIntf" *)
     function ZnShowMeTheMoney: WideString; stdcall;
end;

implementation

Declare uma seção “uses” após a palavra reservada “implementation” e declare as bibliotecas: Math e SysUtils.

OBS: No BDS temos code insight para declaração de bibliotecas!!!



Vamos implementar o método declarado na seção public de “TZnShowMeTheMoney”.

  function TZnShowMeTheMoney.ZnShowMeTheMoney: WideString;
  const
    ZnMsgConst = 'Here is your Money, U$ %f! Do you can see him? look at the message ... ';
  var
    RandomValue: Double;
    RandomDiv: Integer;
  begin
    RandomValue := RandomRange(1, 10000);
    RandomDiv := RandomRange(1, 7);
    RandomValue :=  (RandomValue / RandomDiv);

     Result := Format(ZnMsgConst, [RandomValue]);
  end 

A função que acabamos de codificar, “ZnShowMeTheMoney”, é simplesmente um processamento dummy que retorna aleatoriamente dois valores, os quais são usados como operandos numa divisão cujo o resultado é formatado numa string e retornado na função.
Agora vamos salvar a aplicação, veja ilustração abaixo:

Para o nome do projeto vamos usar “PrjZNShowMoney.bdsproj”. A imagem seguinte mostra, o meu “Project Manager”, para que você possa compara a estrutura do seu projeto com o andamento do nosso exemplo.

Agora vamos publicar nosso serviço: Compile o projeto, em seguida faça o deploy da DLL, “PrjZNShowMoney.dll”, no IIS.

Criei um diretório virtual com alias de “WsShowMeTheMoneyZn”. Para testar, no browser digite: http://localhost/wsshowmethemoneyzn/

Click no link WSDL e você acessará a interface do serviço “IZnShowMeTheMoneyservice”, isso que você esta vendo é mais que uma página web comum.

Neste primeiro exemplo podemos concluir que o desenvolvimento em WS no BDS2006 é semelhante ao do Delphi 7.
É Muito rápido, intuitivo e amigável desenvolver serviços RPC baseados em SOAP/XML no DBS2006, desde que você conheça bem três conceitos:

1 - A estrutura de declarações no Delphi.

2 - Calling Conventions: Convenções de chamadas (traduziremos assim)- Quando declaramos procedimentos ou funções podemos definir, neste momento, a convenção de chamada através das diretivas: register, pascal, cdecl, stdcall, and safecall.
Por exemplo:

  function ZNFuncao(const Xzn, Yzn: Double): Double; cdecl;

  function ZNProcedimento(const Xzn, Yzn: Double; var AoutZn: Double); stdcall;

3- Sistemas distribuídos: Também chamado na literatura de objetos distribuídos.

Outros artigos sobre Webservice e Delphi

Artigo completo (View Full Post)

Webservice: O que é isso? Pra que serve?

Contextualizando

“Cada um dos três últimos séculos foi dominado por uma única tecnologia. (..)

As principais conquistas tecnológicas do séc XX se deram no campo da informação. Entre outros desenvolvimentos, vimos a intalação das redes de telefonia em escala mundial(..) o nascimento e o crescimento sem presedentes da industria de computadores e o lançamento de satélites de comunicação.(..)

A medida que cresce a nossa capacidade de colher, processar e distribuir informações, torna-se ainda maior a necessidade de formas de processamento da informação ainda mais sofisticadas "1

Embora o surgimento dos protocolos de chamda remota (RPCs) não tenha nenhuma dependência com a Internet. É impotante considerar que seu aparecimento foi um combustível poderoso para o cenário de conectividade e interoperabilidade que vivenciamos. Antes da Internet, o discurso sobre a possibilidade de sistemas construídos com linguagens diferentes, rodando em plataformas diferentes, interagirem, era algo bem tímido, digamos assim. É bem provável que uma idéia como essa, antes da Internet, só poderia ser cogitada na cabeça de dois tipo extremos: um leigo ou de um Cyber-visionário.

Naquela época, da imaginação até a realização desta idéia, havia um abismo tecnológico a ser atravessado. Como fazer para que uma aplicação possa reconhecer os métodos da minha, e vice-versa? Qual o tipo de dado que uma determinada função da aplicação “X” retorna? Conhecendo, então, o tipo de dado que retorna, será que meu sistema suporta? E os parâmetros de entrada? Quantos seriam, quais seriam e de que tipo? O visionário diria: “...Eu só preciso de uma interface!!!...”. Todavia, a diversificação de arquiteturas, plataformas e linguagens é tamanha que a construção dessa interface seria demasiadamente dispendiosa, tanto no aspecto do trabalho de codificação, quanto no custo financeiro e mesmo assim, esta interface dificilmente poderia ser re-aproveitada em mais de uma circunstância.

O advento da Internet, de fato, fez com que vislumbrássemos mais de perto essa realização. Agora os computadores já podem interagir, evidentemente com algumas restrições. Na verdade, é o usuário que, através de um computador, interage com um outro computador. Podemos dizer que fisicamente está tudo consolidado. Não existem mais barreiras de arquitetura ou plataformas, desde que todos utilizem o mesmo protocolo. O TCP/IP (Transmission Control Protocol/Internet Protocol) é a língua comum dos computadores que integram a Internet.

Considerando que todos os avanços tecnológicos respondem a estímulos, a informática não foge a essa regra. É muito importante analisarmos algumas afirmações que foram propostas como leis a partir da consolidação da Internet, suas implicações para o ramo de desenvolvimento de software ante a demanda do mercado hoje, são elas:

Lei de Moore:

O número de transistores por centímetro quadrado em um chip dobraria a cada 18 meses.

Lei de Guilder:

A largura de banda da rede triplicaria a cada ano.

Lei de Metcalfe:

A utilidade da rede é equivalente ao quadrado do número de nós.

Embora muitos analistas e programadores ainda não tenham se dado conta, essas leis identificaram o espaço de evolução de nossos sistemas e têm sido um paradigma importante para o mercado de desenvolvimento de software.

Considerando a lei de Moore

Apesar das tecnologias convencionais tirarem proveito do aumento de nós nas redes (Lei de Metcalfe) e também do aumento da largura de banda da Internet (Lei de Guilder), o desenvolvimento de sistemas centralizados ou distribuídos, a partir de tecnologias proprietárias, ignora ou pelo menos tira muito pouco proveito da lei de Moore.

Ao levarmos em conta o aumento do poder de processamento e a miniaturização dos computadores (Moore), está cada vez mais próxima a realidade de que nossos equipamentos domésticos estejam capazes de prover serviços. Seu micro, seu Palm, seu celular já são capazes de fornecer diversos serviços, mas talvez você não saiba que isso já está se tornando uma realidade para sua geladeira, televisão e etc. Em breve, esses equipamentos, hoje coadjuvantes no mundo dos grandes servidores, passarão a exigir uma participação mais ativa no mundo dos objetos distribuídos. E como é que nós desenvolvedores iremos criar sistemas, não mais centralizados, que não seguem mais as regras às quais estamos acostumados? Ou como fazer para integrar sistemas de plataformas heterogenias e até mesmo sistemas legados?

Estamos caminhando para um mundo cada vez mais conectado, onde um número crescente de equipamentos, sistemas, aparelhos e pessoas precisarão se comunicar e trocar informações. Conectividade, integração, fusão, tornaram-se termos corriqueiros e são as aplicações construídas com uma arquitetura distribuída que farão desta visão a realidade, a qual somos nós os responsáveis por construir.

Cada vez mais, nos dia de hoje, cresce a demanda nos departamentos de informática dos mais diversos setores, corporativos ou não, por soluções que venham viabilizar e otimizar os serviços, a troca de informação, a interação e a integração de sistemas de informação. Precisamos, então, desenvolver interfaces capazes de atender essas necessidade de maneira eficiente e eficaz.

"...A fusão dos computadores e das comunicações teve uma profunda influência na forma como os sistemas computacionais eram organizados. Está totalmente ultrapassado o conceito de um "centro de computadores", (...) o velho modelo de um computador atendendo a todas as necessidades computacionais da organização foi substituido pelas chamdas redes de computadores, nais quais os trabalhos são realizados por uma série de computadores interconectados..."2

Os WebServices podem conectar os sistemas da empresa com serviços de parceiros, cadeias de fornecimento altamente otimizadas ou canais de entrega mais amplos, provendo um serviço em tempo real ao consumidor de um modo melhorado.

Os WebServices podem ser utilizados ainda, para agregar conteúdo interno e externo a aplicações, provendo portais mais dinâmicos e colaborativos. Eles são um modelo de aplicação que combina aspectos de desenvolvimentos baseados em componentes reutilizáveis. Este modelo está tendo grande aceitação no mercado e apoio de grandes indústrias de software, como Microsoft, IBM e Sun.

Assuntos Relacionados:

http://www.sei.cmu.edu/architecture/
http://pt.wikipedia.org/wiki/Arquitetura_de_software
http://en.wikipedia.org/wiki/Three-tier_%28computing%29
http://en.wikipedia.org/wiki/Distributed_computing

---

[2]Tanenbaun S. Andrew, Redes de computadores página 2

---

---

[1]Tanenbaun S. Andrew, Redes de computadores página 1

Artigo completo (View Full Post)

Construindo um WebService - Delphi

Esse exemplo foi desenvolvido em Delphi 7

Iniciando a implementação do nosso WebService, voltaremos na barra de menu do principal do Delphi: File ► New ► Other ► WebService ► SOAP Server Application.

Em segida prossiga com o passo-a-apsso Abaixo:

Click no ícone SOAP Server Application. Na próxima caixa de diálogo você terá de escolher que tipo de tecnologia de script do lado servidor seu Webservice irá utilizar. Para este exemplo marque a opção “CGI Satand-alone executable”.

Em seguida o Delphi irá perguntar se desejamos que ele crie uma interface para a aplicação. Clicke em “Yes”. Sim, queremos criar a interface. Se você deseja que seu serviço seja utilizado por outro sistema, será necessário para isso criar uma interface desse serviço. No protocolo de Webservice esse interface estará definida dentro de um padrão chamado WSDL. A grande vantagem de vc desenvolver webservices em Delphi é que ele te abstrai de todos esses detalhes. Por isso, poderemos prossegui nosso exmplo sem a obrigatoriedade de lermos um catatal de especicifações de protocolos. HAUHAUHHA ..... graças a Deus. Foi mal, mas .... isso é muito bom.

Em “service name” digite “Servicos”, fazendo isto estamos criando uma interface para o nosso serviço com o nome de “servicos”.

Para a seleção de Service activation model definiremos Per Request, escolhendo essa opção estaremos definido como as requisições ao nosso serviço serão atendidas. Você pode desmarcar a checkedbox (generate comments) como o nome já diz, desta forma o Delphi, quando acabarmos de definir todos os parâmetros dessa aplicação, não gerará comentários sobre as Units criadas. Veja o exemplo abaixo, para um melhor acompanhamento siga estritamente a nomenclatura aqui utilizada.

Note que foram criadas Quatro unidades: Projetc1, ServicosImpl, ServicosIntf, Unit1. No teclado aperte Ctrl+F12 (View Unit), e compare com a figura ao lado.

ServicosImpl: unidade de implementação, correspondente ao arquivo ServicosImpl.pas

ServicosIntf: Unidade onde estarão as declarações referentes à interface. Correspondente ao arquivo ServicosIntf.pás.

Já é hora de salvar o que foi feito até agora pressione "CTRL + Shift + S".

Junto com o WebModule criado é automaticamente adicionado os componentes fundamentais para a implementação do servidor. Para visualizar o WebModulo, no teclado aperte Ctrl+F12 (View Unit), e selecione Unit1.

    HTTPSoapDispatcher: Recebe e envia mensagens (Web) para o objeto especificado em sua propriedade
                                       “Dispatcher”, para que sejam decodificadas. Registra-se automaticamente junto ao
                                       WebModule, fazendo com que não seja necessário a criação de actions que direcionam
                                       as requisições para o HTTPSoapDispatcher. Desta forma ele pode receber todas as
                                       requisições automaticamente.
  
    HTTPSoapPascalInvoker: Recebe as mensagens enviadas pelo HTTPSoapDispatcher e a interpreta, fazendo com
                                             que sejam executados os métodos correspondentes à solicitação. E também faz o
                                            caminho contrário codificando o retorno do método para o padrão SOAP. 
  
    WSDLHTMLPublish: Publica todas as informações registradas pelo Web Service, usando WSDL.
  

Criando o primeiro serviço

Nosso primeiro exemplo consiste em criar um serviço que informe a data e a hora local do servidor. Para isso implementaremos uma função que retorne esta a data, dia da semana e hora.

Em ServicosIntf , vamos declarar o cabeçalho da função “DataHoraDiaLOcal”. seguida codificaremos o corpo desta função em ServicosImpl. Veja no exemplo abaixo, declaramos a função na sessão “Type”, logo abaixo do GUID:

Aqui declaramos somente a assinatura, note que o nome dessa Unit sugere uma área de delaração como a seção Interface numa unit .pas comun, ServicosIntf. Logo, para codificarmos o corpo desta função termos de fazê-lo na unit correspondente a seção de implementation, podemos fazer um “Ctrl+C” do cabeçalho(function DataHoraDiaLOcal: string: stdcall;) e colarmos em ServicosImpl.

Feito o “Ctrl+V” na sessão Public de ServicosImpl. Com o cursor ainda na mesma linha, pressione “Ctrl+Shift+C” para que o Delphi escreva o corpo da função, observe o exemplo abaixo:

         function TServicos.DataHoraDiaLocal: String;
        begin
           Result  := FormatDateTime( 'dd mmmm, dddd, yyyy. HH:nn:ss ' , Now)
         end;
  

Pronto, no que diz respeito a codificação nosso primeiro exemplo termina aqui, basta que Compilemos a aplicação (no Menu: Project ► Compile Project, ou pelo atalho "Ctrl + F9") , sempre lembrado de salvar o exemplo com SaveAll (Ctrl+Shift+S). Contudo, antes de executar a aplicação é preciso fazer o deploy dessa aplicação. Utilizaremos o IIS para isso. Portanto, crie uma pasta virtual no IIS apontado para o diretório onde está o executável compilado pelo exemplo que estamos criando. Defina como documento principal o .exe. Pronto, acabou!!

Com a aplicação devidamente compilada, salva e feito o deploy. Podemos testá-la no browser, digitando na barra de endereços:

http://LocalHost/ nome_da_pasta_virtual

Repare que a nossa função está publicada. Clicke no browser em Iservicos [WSDL] para visualizar a implementação. É preciso salvarmos este arquivo XML para que possamos importar esta interface para a aplicação cliente que construiremos num outro post.

Veja o próximo no exemplo a página onde Delphi gerou todo o código XML correspondente a nossa implementação. Podemos também gerar um arquivo XML com a definição do nosso serviço.

No próximo post exemplificaremos um aplicativo cliente para consumir esse serviço que acabamos de criar.

Mais artigos no Estação Zn sobre Ws

Preciso saber mais sobre Webservices ...

Artigo completo (View Full Post)