Consumindo Web Services usando Proxy Dinâmico

Publicado por Ricardo Ushisima
25/2/2011
Categoria:
Tags: , , ,

No meu artigo anterior, eu mostrei como expor um POCO como Web Service usando Spring Framework. Neste artigo, darei continuidade explicando como consumir esse Web Service usando proxy dinâmico também do Spring Framework.

O método mais usado para consumir Web Services em .NET é usando proxies estáticos gerados usando o Visual Studio a partir do WSDL do Web Service. Esse é o método mais rápido e fácil de consumir Web Service quando o serviço é disponibilizado por terceiros. Porém, quando o serviço sendo consumido é contratado por você, existe uma maneira mais simples ainda e mais fácil de manter, que é usando proxies dinâmicos do Spring Framework.

Para que o Spring consiga criar os proxies dinamicos, é preciso que se tenha as interfaces do serviço que se deseja consumir e todas as classes relacionadas (Value Objects por exemplo). Adotando uma programação por contrato, tem-se esses elementos naturalmente.

Na aplicação exemplo do artigo anterior, a interface (contrato) do serviço está em um componente separado que chamei de API. Esse componente é compartilhado entre o servidor (que implementa o serviço) e o cliente (que consome o serviço).

Para demonstrar como usar os proxies dinâmicos, irei expandir o exemplo anterior, adicionando uma aplicação cliente (um web site) que irá usar o serviço de Conversão de Moedas.

Código do ASPX (Default.aspx):

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="_Default" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title>Currency Converter</title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <h1>Currency Converter</h1>
        <label>From:</label><br />
        <asp:DropDownList ID="FromCurrencyDropDownList" runat="server">
            <asp:ListItem Selected="True">BRL</asp:ListItem>
            <asp:ListItem>EUR</asp:ListItem>
            <asp:ListItem>USD</asp:ListItem>
        </asp:DropDownList><br /><br />
        <label>To:</label><br />
        <asp:DropDownList ID="ToCurrencyDropDownList" runat="server">
            <asp:ListItem>BRL</asp:ListItem>
            <asp:ListItem Selected="True">EUR</asp:ListItem>
            <asp:ListItem>USD</asp:ListItem>
        </asp:DropDownList><br /><br />
        <label>Amount:</label><br />
        <asp:TextBox ID="ValueTextBox" runat="server"></asp:TextBox>
        <asp:Button ID="ConvertButton" runat="server" Text="Convert" OnClick="ConvertButton_Click" /><br /><br />
        <label>Result:</label><br />
        <asp:TextBox ID="ResultTextBox" runat="server" ReadOnly="True"></asp:TextBox>
    </div>
    </form>
</body>
</html>

Code-behind do ASPX (Default.aspx.cs):

using System;
using SpringTutorial;

public partial class _Default : System.Web.UI.Page
{
    public ICurrencyService CurrencyService { get; set; }

    protected void Page_Load(object sender, EventArgs e)
    {
    }

    protected void ConvertButton_Click(object sender, EventArgs e)
    {
        string fromCurrency = FromCurrencyDropDownList.SelectedValue;
        string toCurrency = ToCurrencyDropDownList.SelectedValue;
        decimal amount = decimal.Parse(ValueTextBox.Text);
        decimal result = CurrencyService.Convert(fromCurrency, toCurrency, amount);
        ResultTextBox.Text = result.ToString();
    }
}

No code-behind do ASPX, irei utilizar o Spring para injetar o serviço na propriedade CurrencyService. Usando um mecanismo similar ao de expor um serviço, a injeção de dependencia (DI) em ASPX é feita também usando um HTTP Handler customizado.

Web.config:

<?xml version="1.0"?>
<configuration>
	<configSections>
    <!-- (...) -->
		<sectionGroup name="spring">
			<section name="context" type="Spring.Context.Support.WebContextHandler, Spring.Web"/>
		</sectionGroup>
	</configSections>
	<spring>
		<context>
			<resource uri="file://~/Spring.xml"/>
		</context>
	</spring>
	<appSettings/>
	<connectionStrings/>
	<system.web>
    <!-- (...) -->
		<httpHandlers>
			<remove verb="*" path="*.aspx"/>
			<add verb="*" path="*.aspx" type="Spring.Web.Support.PageHandlerFactory, Spring.Web"/>
      <!-- (...) -->
		</httpHandlers>
		<httpModules>
			<add name="Spring" type="Spring.Context.Support.WebSupportModule, Spring.Web"/>
      <!-- (...) -->
		</httpModules>
	</system.web>
  <!-- (...) -->
</configuration>

Na configuração do Spring existe a criação do proxy dinâmico usando uma fábrica de objetos do Spring (WebServiceProxyFactory) aonde se especifica a URL do serviço e a interface a que ele responde. Também na configuração do Spring está a injeção de dependência no ASPX do proxy dinâmico mencionado anteriormente.

Spring.xml:

<?xml version="1.0" encoding="utf-8" ?>
<objects xmlns="http://www.springframework.net" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://www.springframework.net http://www.springframework.net/xsd/spring-objects.xsd">
  <object id="currencyService" type="Spring.Web.Services.WebServiceProxyFactory, Spring.Services">
    <property name="ServiceUri" value="http://localhost:52721/WebService/CurrencyServiceWS.asmx"/>
    <property name="ServiceInterface" value="SpringTutorial.ICurrencyService, SpringTutorial.API"/>
  </object>
  <object type="Default.aspx">
    <property name="CurrencyService" ref="currencyService" />
  </object>
</objects>

Então, qualquer alteração no contrato do serviço reflete imediatamente na aplicação cliente já que o componente que define o contrato é compartilhado pelos dois lados.

Desta forma, o uso de proxies dinamicos para consumir Web Services fica muito simples e fácil, desde que você tenha controle sobre as duas parte da aplicação.





Desenvolvido por hacklab/ com WordPress