Embed Size (px)
Citation preview
DEPARTAMENTO DE COMPUTAÇÃO
CURSO DE PÓS-GRADUAÇÃO EM ENGENHARIA DE SOFTWARE COM UML
“LATO-SENSU”
CARLOS EDUARDO PASQUETO BORIN
APLICAÇÃO DA SERVICE ORIENTED ARCHITECTURE (SOA) UTILIZANDO O
FRAMEWORK WINDOWS COMMUNICATION FOUNDATION (WCF)
Londrina
2012
CARLOS EDUARDO PASQUETO BORIN
APLICAÇÃO DA SERVICE ORIENTED ARCHITECTURE (SOA) UTILIZANDO O
FRAMEWORK WINDOWS COMMUNICATION FOUNDATION (WCF)
Monografia apresentado à Banca Examinadora
do Curso de Pós-Graduação em Engenharia de
Software com UML do Centro Universitário
Filadélfia de Londrina - UniFil como requisito
parcial para obtenção do grau de Especialista
em Engenharia de Software sob a orientação
do Professor Msc. Sergio Akio Tanaka.
LONDRINA
2012
CARLOS EDUARDO PASQUETO BORIN
APLICAÇÃO DA SERVICE ORIENTED ARCHITECTURE (SOA) UTILIZANDO O
FRAMEWORK WINDOWS COMMUNICATION FOUNDATION (WCF)
Monografia apresentado à Banca Examinadora do Curso de Pós-Graduação em
Engenharia de Software do Centro Universitário Filadélfia de Londrina - UniFil em
cumprimento a requisito parcial para obtenção do título de Especialista em
Engenharia de Software.
APROVADA PELA COMISSÃO EXAMINADORA
EM LONDRINA, 18 DE MAIO DE 2012.
Prof. MSc. Sergio Akio Tanaka (UniFil) - Orientador
Profa. MSc. Simone Sawasaki Tanaka (UniFil) -
Examinadora
Londrina, 18 de Maio de 2012.
Ao Aluno: Carlos Eduardo Pasqueto Borin.
Prezado(a) Senhor(a):
Tem a presente a finalidade de NOTIFICAR-LHE nos termos do art. 867 e
seguintes do Código de Processo Civil com vistas a prevenir responsabilidades,
provendo a conservação e ressalva de direitos. A “UniFil” em razão da
apresentação recorrente de trabalhos onde se tem efetuado a cópia de trechos e até
capítulos ou trabalhos inteiros, vem notificá-lo que tal pratica é vedada pela Lei de
Direitos Autorais nº 9.610/98 em seus artigos 1º, 5º incisos VI e X, 7º, 22º, 24º inciso
IV, 29º e 41º, cumulados com a nova redação dos artigos 184 e 186 do Código penal
dados pela lei 10.695/2003, que prevê não apenas a proibição de cópia total ou
parcial sem atribuição da devida autoria como inclusive pena de detenção de até
quatro anos mais multa para quem assim proceder. Assim sendo, considera-se o
aluno: Carlos Eduardo Pasqueto Borin, da Pós-Graduação em Engenharia de
Software com UML, Linha de Formação: Engenharia de Software, ciente de previsão
legal que veda tal prática e se mesmo assim optar por faze-lo deverá arcar sozinho
com o ônus de tal ato, quer seja ele penal, cível ou administrativo, não podendo a
Instituição de Ensino ser responsabilizada por opção do aluno sem seu
consentimento ou anuência. .
Na esfera administrativa desde já ficam, também devidamente notificados,
que os trabalhos copiados na íntegra ou que apresentem cópia parcial, serão
sumariamente reprovados; bem como estarão sujeitos a outras medidas cabíveis.
Conforme Regulamento da instituição no qual relata o seguinte: “Na constatação de
procedimentos ilícitos para a elaboração dos trabalhos de estágio, caracterizando
cópias parciais ou integrais (plágio), será atribuído a média 0,0 (zero) ao aluno no
bimestre em curso, não cabendo recurso”.
Sem mais para o momento.
Atenciosamente.
Aluno:________________________________________
AGRADECIMENTOS
Primeiramente a Deus, que me deu sabedoria para concluir mais esta etapa
da minha vida.
A minha esposa Fabiane Yuri Yamacita e ao meu filho Felipe, por todo
apoio, companheirismo e paciência nesta jornada.
Ao meu orientador, Prof. Msc. Sergio Tanaka, que com toda paciência e
sabedoria esteve sempre orientando, corrigindo e auxiliando em cada etapa deste
trabalho, além de compartilhar todo seu conhecimento e experiências durante o
curso.
A todos os docentes deste curso por terem contribuído com nosso
aprendizado e aperfeiçoamento.
“Numa escala mais humana, os produtos de software intensivos ajudaram a
curar o doente e deram voz ao mudo, mobilidade ao debilitado e oportunidade ao
incapacitado. De todas essas perspectivas, o software é uma parte indispensável de
nosso mundo moderno”. (Grady Brooch, 1998).
BORIN, Carlos Eduardo Pasqueto. Aplicação da Service Oriented Architecture (SOA) utilizando o Framework Windows Comunication Foundation (WCF). Londrina, 2012, 57f. Monografia do Curso de Pós-Graduação em Engenharia de Software com UML. Centro Universitário Filadélfia de Londrina - UniFil, Londrina, 2012.
RESUMO
Este trabalho apresenta a aplicação da engenharia de software em sistemas orientados a serviços utilizando a arquitetura de software orientada a serviços (SOA). Um estudo de caso intitulado WcfServicoReserva foi implementado para demonstrar a aplicabilidade da arquitetura SOA na plataforma Microsoft. O projeto foi modelado em Unified Modeling Language (UML) utilizando a ferramenta IBM Rational Rose, para o desenvolvimento desse software foi utilizado o framework Windows Communication Foundation (WCF) que faz parte do framework .NET 4.0, e a IDE de implementação foi o Visual Studio 2010 utilizando a linguagem orienta a objetos C#. O principal objetivo deste trabalho foi demonstrar os benefícios que essa arquitetura oferece pensando no software como negócio, dividindo as responsabilidades lógicas em pequenas partes e disponibilizando através de serviços, que garantam a interoperabilidade de tecnologias e a reutilização do negócio da empresa.
Palavras-chave: SOA; UML; WCF.
BORIN, Carlos Eduardo Pasqueto. Aplicação da Service Oriented Architecture (SOA) utilizando o Framework Windows Comunication Foundation (WCF). Londrina, 2012, 57f. Monografia do Curso de Pós-Graduação em Engenharia de Software com UML. Centro Universitário Filadélfia de Londrina - UniFil, Londrina, 2012.
ABSTRACT
This paper presents the application of software engineering in service-oriented systems using software-oriented architecture (SOA). A case study titled WcfServicoReserva was implemented to demonstrate the applicability of SOA on the Microsoft platform. The project was modeled in UML using Rational Rose tool, on development it was used framework Windows Communication Foundation (WCF), which is a part of the framework. NET 4.0, the IDE used to implement the software was the Visual Studio 2010 and the development language used was C # objects. The aim of this study was to demonstrate the benefits that this architecture offers, thinking about software as a business, dividing the logical responsibilities into small pieces, providing services that ensure interoperability and reuse of technologies from company's business.
Keywords: SOA; UML; WCF.
LISTA DE FIGURAS
Figura 1: Classificação Diagramas UML ................................................................... 19
Figura 2: Uma aplicação composta de 4 serviços. As setas indicam a sequência da
troca de mensagens .................................................................................................. 21
Figura 3: Uma aplicação orientada a serviço. ........................................................... 25
Figura 4: Comunicação WCF. ................................................................................... 26
Figura 5: Transporte e codificação para bindings. ..................................................... 28
Figura 6: Endpoint. .................................................................................................... 28
Figura 7: Escolhendo um binding. ............................................................................. 29
Figura 8: Diagrama de Caso de Uso. ........................................................................ 31
Figura 9: Diagrama de Classes. ................................................................................ 32
Figura 10: Diagrama de Sequência. .......................................................................... 33
Figura 11: Criar um projeto WCF no Visual Studio 2010. .......................................... 34
Figura 12: Configurar uma classe para DataContract. .............................................. 35
Figura 13: Contrato do serviço através de Interface. ................................................. 36
Figura 14: Codificação do serviço implementando a interface do serviço. ................ 37
Figura 15: Arquivo App.config. .................................................................................. 38
Figura 16: Microsoft WCF Service Host. ................................................................... 39
Figura 17: Arquivo WSDL. ......................................................................................... 40
Figura 18: Aplicativo de teste embutido no Visual Studio para teste do serviço........ 41
Figura 19: Chamada ao método ValidarUsuario(). .................................................... 42
Figura 20: Visualização do envio e recebimento do método ValidarUsuario() em
formato SOAP............................................................................................................43
Figura 21: Criação do projeto do tipo ConsoleApplication para consumir o serviço
WcfServicoReserva....................................................................................................45
Figura 22: Adicionando a referência do serviço WcfServicoReserva. ......................46
Figura 23: Informando o endereço do arquivo WSDL do serviço
WcfServicoReserva....................................................................................................47
Figura 24: Referência do serviço WcfServicoReserva adicionada ao projeto...........48
Figura 25: Chamada ao método ListarSalas() do serviço WcfServicoReserva..........49
Figura 26: Resultado do método ListarSalas() do serviço WcfServicoReserva.........49
Figura 27: Criação projeto do tipo Aplicativo Java para consumir o serviço
WcfServicoReserva....................................................................................................50
Figura 28: Criar um Cliente para serviço web para consumir o serviço
WcfServicoReserva....................................................................................................51
Figura 29: Informando o endereço do arquivo WSDL do serviço WcfServicoReserva.
....................................................................................................................................52
Figura 30: Referência do serviço WcfServicoReserva adicionada ao projeto...........53
Figura 31: Chamada ao método ListarSalas() do serviço WcfServicoReserva em
Java............................................................................................................................53
Figura 32: Resultado do método ListarSalas() do serviço WcfServicoReserva
implementado em Java..............................................................................................54
LISTA DE TABELAS
Tabela 1: Tipos de diagramas oficiais da UML..........................................................18
LISTA DE ABREVIATURAS E SIGLAS
ASMX ASP.NET Webservices Source
CLR Common Language Runtime
COM Component Object Model
DCOM Distributed Component Object Model
IBM International Business Machines
IDE Integrated Development Environment
MSMQ Message Queuing
OMG Object Management Group
SOA Service-oriented Architecture
SOAP Simple Object Access Protocol
UML Unified Modeling Language
XML Extensible Markup Language
WCF Windows Communication Foundation
WSDL Web Services Description Language
SUMÁRIO
1 INTRODUÇÃO ................................................................................................ 14
2 REVISÃO DE LITERATURA .......................................................................... 17
2.1 UNIFIED MODELING LANGUAGE (UML) .......................................................... 17
2.2 SERVICE-ORIENTED ARCHITECTURE ............................................................ 19
2.3 WINDOWS COMMUNICATION FOUNDATION.................................................. 24
2.4 CONSIDERAÇÕES SOBRE O SOFTWARE ...................................................... 30
3 ESTUDO DE CASO ........................................................................................ 31
3.1 DATACONTRACS ............................................................................................... 35
3.2 CONTRATO DO SERVIÇO ................................................................................. 35
3.3 IMPLEMENTAR O CONTRATO.......................................................................... 36
3.4 CONFIGURAR ENDPOINTS .............................................................................. 37
3.5 HOSPEDAR O SERVIÇO ................................................................................... 38
4 PERSPECTIVAS PARA TRABALHOS FUTUROS ........................................ 44
5 CONCLUSÃO..................................................................................................58
REFERÊNCIAS.........................................................................................................59
1 INTRODUÇÃO
Uma equipe de Tecnologia da Informação (TI) consiste de muitas pessoas e
muitos softwares, cada um no qual contribuindo de forma uniforme para ajudar a
alcançar os objetivos do negócio da empresa. Cada um possui requisitos
específicos para gerenciamento, tal como sistemas, rede de comunicações,
aplicações, informações, serviços, processos, banco de dados, repositórios,
integrações, warehouses, migrações, etc.
Atualmente, existem enormes mudanças e desafios encontrados pela TI
através das mudanças de requisitos no mundo real. Depois de muitos anos se
deparando com problemas, incompatibilidade entre sistemas e até mesmo a
recodificação dos mesmos, tornou-se necessário a busca de um padrão que atenda
a necessidade atuais e que no futuro seja compatível com as novas tecnologias que
surgem no mercado no mundo de tecnologia.
Através da Arquitetura de Software Orientada a Serviços (SOA) que as
equipes de TI encontraram essa solução, que é completamente baseado em
padrões abertos de comunicação disponíveis como serviços pela rede. Serviços
escondem a complexidade dos sistemas heterogêneos que existem em ambientes
de TI, mas para o mundo orientado a serviço tornar-se realidade, as companhias
devem mover-se para uma nova arquitetura denominada SOA, que é uma
arquitetura que representa as funcionalidades de software através de serviços pela
rede.
Uma verdadeira arquitetura de SOA deve ser uma aplicação na qual todas as
funcionalidades são definidas como serviços independentes e invocados através de
interface, no qual pode ser chamada em sequencias definidas do processo de
negócio.
Esta monografia realiza uma breve análise sobre a Linguagem de
Modelagem Unificada (UML), sobre a Arquitetura de Software Orientada a Serviços
(SOA) e sobre o Windows Communication Foundation (WCF), tecnologia Microsoft
disponível para implementação de SOA, criando um estudo de caso com o objetivo
de demonstrar a aplicação dessa tecnologia em um ambiente de Tecnologia da
Informação (TI) de uma empresa de desenvolvimento de software.
Essa pesquisa traz como tema a aplicação de SOA utilizando a tecnologia da
Microsoft, que no decorrer dos anos e do avanço da plataforma de desenvolvimento,
foi disponibilizando novas tecnologias para a implementação de aplicações
distribuídas, todas com o mesmo objetivo: comunicação entre objetos em sistemas
distribuídos através da rede.
Hoje existe uma série de tecnologias, tais como: COM/DCOM/COM+/ES,
.NET Remoting, MSQM, ASMX desenvolvidas pela Microsoft, cada uma com suas
características específicas.
O grande problema é que cada framework é disponível com um modelo de
programação, para cada framework faz-se necessário o esforço do aprendizado
específico, e muitas vezes é necessário utilizar várias dessas tecnologias no mesmo
software, aumentando assim sua complexidade, além de que todos são restritos
para plataforma Windows. O objetivo desse projeto foi demonstrar como está mais
simples atualmente, desenvolver aplicações orientadas a serviços através do
framework WCF.
A justificativa para a utilização de SOA é que o mesmo está mudando o
paradigma de desenvolvimento de software, pois oferece a divisão de
responsabilidades e a reutilização da regra de negócio através dos serviços criados,
essas funcionalidades já existentes ficam disponíveis para qualquer sistema que de
alguma forma necessita dessa informação.
O WCF é a tecnologia ideal para desenvolvimento de serviços para
plataforma Windows. É a unificação das tecnologias distribuídas da Microsoft, onde
existe apenas um modelo de programação, mas várias formas de ligar os pontos, ou
seja, uma comunicação independente da linguagem, garantindo a interoperabilidade
entre as tecnologias.
O principal objetivo deste trabalho foi demonstrar como a Microsoft oferece
aos seus desenvolvedores a possibilidade de desenvolver aplicações na arquitetura
SOA através da tecnologia WCF. Alguns objetivos específicos foram elencados tais
como:
a) demonstrar a evolução da tecnologia Microsoft para aplicação distribuída;
b) demonstrar os padrões abertos para comunicação de sistemas independente
da tecnologia utilizada;
c) aplicar o SOA com o WCF;
d) implementar um estudo de caso.
A metodologia escolhida para esta monografia é a pesquisa descritiva que
tem como finalidade descrever e interpretar os fenômenos estudados, observando-
os em sua natureza e em seus processos. Os dados obtidos devem ser analisados
e interpretados e podem ser qualitativos ou quantitativos. Na maioria dos casos,
essas pesquisas envolvem levantamento bibliográfico, entrevistas com pessoas que
tiveram experiências práticas com o problema pesquisado e análise de exemplos
que darão suporte para a compreensão do tema (GIL, 1995).
O estudo de caso foi abordado neste trabalho e pode ser caracterizado por
ser um estudo intenso e profundo a respeito de um assunto em relação a uma
unidade social. O foco de estudo pode ser um indivíduo, um grupo social específico,
uma comunidade ou uma organização (LEITE, 2008).
A pesquisa será fundamentada em referência bibliográfica de obras
existentes, como livros, revistas e sites (GIL, 1995).
Este trabalho esta organizado em capítulos. O capítulo 2 apresenta os
principais conceitos utilizados neste trabalho tais como UML, SOA e WCF. O
capítulo 3 apresenta o estudo de caso intitulado WcfServicoReserva. O capitulo 4
apresenta as perspectivas para trabalhos futuros e, finalmente no capítulo 5 são
apresentadas as conclusões desse trabalho.
2 REVISÃO DE LITERATURA
Este capítulo apresenta os principais conceitos utilizados para a
compreensão deste trabalho.
2.1 UNIFIED MODELING LANGUAGE (UML)
Segundo Fowler (2005), a UML é uma família de notações gráficas, apoiada
por um metamodelo único que ajuda na descrição e no projeto de sistemas de
software, particularmente daqueles construídos utilizando o estilo orientado a
objetos. O fator fundamental para a criação de uma linguagem de modelagem de
software é que as linguagens de programação não estão em um nível de abstração
alto para facilitar a análise sobre o projeto. A Object Management Group (OMG) que
é um consórcio aberto de empresas é quem controla o padrão da UML, onde
estabelece padrões que suportam interoperabilidade, especificamente para
sistemas orientado a objetos.
A UML 2.0 compõe-se de 13 tipos diagramas oficiais, listados na Tabela 1.
Tabela 1: Tipos de diagramas oficiais da UML (Fonte: Fowler, 2005, p. 33.)
Os diagramas UML são classificados conforme a Figura 1.
Figura 1: Classificação Diagramas UML.
Fonte: (Fowler, 2005, p 34.)
2.2 SERVICE-ORIENTED ARCHITECTURE
O termo orientação a serviço é um paradigma que tem como objetivo criar
unidades de solução lógicas separadas individualmente e projetadas de modo que
elas possam ser utilizadas repetidamente para execução de uma estratégia
específica do negócio da empresa, para essa solução lógica dá-se o nome de
serviço.
O SOA representa um modelo arquitetural que tem como objetivo aumentar
a agilidade e custo-efetividade de uma empresa e reduzir a sobrecarga existente na
equipe de TI. E é através da criação de serviços, com a divisão da responsabilidade
desacoplando a regra de negócio da empresa, que nos proporciona uma maior
flexibilidade do negócio para eventuais mudanças e evolução nos requisitos.
Segundo Erl (2008), afirma que para se aplicar de uma forma inteligente e
projetar serviços que serão realmente reutilizados, é necessário que o paradigma de
desenvolvimento atual sofra profundas modificações no processo da empresa,
envolvendo governança e tecnologia, para que seja capaz de definir de forma
correta o tamanho ideal de cada serviço, essas decisões são baseadas nos
princípios de design de serviços e devem obedecer as características fundamentais
do serviço, que obrigatoriamente deve ser reutilizável, compartilhar um contrato
formal, ter baixo acoplamento, ser autônomo e ser capaz de ser descoberto.
Com uma aplicação de SOA inteligente, Erl 2009, afirma que acabarão as
funcionalidades redundantes e a dificuldade de evolução dos sistemas de TI,
possibilitando maior agilidade nos negócios. A atual complexidade de implantação
de uma solução SOA é única e exclusiva de cada empresa, entretanto é
caracterizado por uma introdução de novas tecnologias e plataformas que
especificamente possibilita a criação, execução e evolução de sistemas conectados.
Para Erl (2009), sistemas conectados é uma aplicação que é distribuída
entre computadores interligados através de uma rede, como na Figura 2, cada
serviço possui uma parte da aplicação que executa uma parte lógica do negócio,
que trabalham juntas trocando mensagens através de um protocolo de rede.
Figura 2: Uma aplicação composta de 4 serviços. As setas indicam a sequência da
troca de mensagens.
Fonte: ERL et al (2009). p. 30.
Segundo John Sharp (2010), inicialmente a Microsoft projetou o Component
Object Model (COM) para possibilitar a comunicação entre componentes e
aplicações executando no mesmo computador. Depois ela desenvolveu o
Distributed Component Object Model (DCOM), uma extensão do COM, na qual
permite aplicações acessar componentes que estão em outros computadores
através da rede e posteriormente foi criado o COM+, que incorporou características
tal como integração com Microsoft Transaction Server que possibilita agrupar
operações em componentes juntos em transações, e os resultados dessas
operações poderiam ser feitos permanentemente (commit) se tudo ocorresse com
sucesso ou automaticamente cancelados (rollback) caso algum erro ocorresse.
Além disso, COM+ forneceu mais recursos, como gerenciamento
automático de recurso, por exemplo, ao conectar em um banco de dados,
automaticamente a conexão era fechada após o uso do componente e operações
assíncronas (útil quando uma aplicação faz uma requisição para um componente
que pode demorar em processar e responder a requisição, o componente continua
processando e avisa a aplicação quando a operação foi completada).
A evolução do COM+ veio através do .NET framework, que herdou suas
funcionalidades e foi renomeado para Enterprise Services. O .NET framework
também forneceu outra grande tecnologia para comunicação através da rede, o
.NET Remoting, que fornece intercomunicação em ambientes protegidos que
exigem alta performance e que utilizam a tecnologia .NET através do protocolo
TCP/IP, permitindo uma aplicação cliente acessar um objeto remoto do servidor
como se ele estivesse sendo executado localmente, dentro do aplicativo cliente.
Tecnologias como COM, DCOM, COM+, Enterprise Services e .NET
framework Remoting tem sucesso em ambientes internos ou seja, interligados na
mesma rede e na plataforma Windows. Enquanto a Microsoft estava desenvolvendo
o COM e o DCOM, a World Wilde Web apareceu. O mundo real é baseado na
internet, que fornece uma infraestrutura para desenvolvedores construir software e
componentes para comunicação com outros aplicativos em qualquer lugar do
mundo, independente de plataforma.
Com a evolução da internet surgiu o web service, que é uma aplicação ou
componente que executa em um servidor web ao invés do computador do usuário,
onde executa operações através de requisições e envia a resposta de volta para o
computador do usuário. O web service pode também invocar operações para outros
web services, hospedados em outro servidor na internet, web services não são
dependentes de linguagem e plataforma, isso se deve aos padrões de comunicação
abertos criados para internet, com o formato de hora, protocolo e tratamento de
segurança.
John Sharp (2010), afirma que para que essa comunicação independente
de plataforma seja possível, aplicações cliente e web services precisam utilizar um
protocolo de comunicação comum para ambos para o envio e recebimento de
mensagens. Um aplicativo cliente precisa saber quais mensagens pode enviar e
como será a resposta recebida do web service.
Um padrão aberto de comunicação extremamente utilizado é o Simple
Object Access Protocol (SOAP), que é um protocolo baseado em (Extensible
Markup Language) XML para permitir que aplicações troquem informações pela
internet utilizando o protocolo (Hypertext Transfer Protocol) HTTP, e em julho de
2003, com sua versão 1.2 tornou-se uma recomendação W3C.
John Sharp (2010) afirma que, por SOAP ser um padrão, fornece muitos
benefícios tais como:
protocolo de comunicação para comunicação entre aplicações pela
internet;
possui um formato para envio de mensagens;
é independente de plataforma e linguagem;
totalmente baseado em XML;
simples e extensível;
permite comunicação entre firewalls.
Por todas essas características, SOAP transformou-se no padrão mais
utilizado em serviços, e foi utilizado no estudo de caso desse trabalho.
Segundo Erl (2009), foi através dos princípios dos web services que os
desenvolvedores perceberam que os web services poderiam ser aplicados de uma
forma mais generalizada, alcançando o conceito de software como serviço para a
implementação de uma arquitetura orientada a serviço SOA.
Para Erl (2008), o termo chave de SOA é a capacidade de reutilização de
softwares proprietários existentes e expor a funcionalidade desses softwares
através de serviços.
Os conceitos chaves para uma implementação de sucesso de SOA são:
fornecer uma interface reutilizável e extensível baseado em padrões
abertos para a maximização de interoperabilidade;
fornecer um ambiente de hospedagem escalonável no qual um serviço
possa responder rapidamente a requisições do usuário, mesmo sobre
uma carga extrema.
Para alcançar esses objetivos, a Microsoft criou o Windows Communication
Foundation.
2.3 Windows Communication Foundation
O grande problema das tecnologias anteriores citadas nesse trabalho
desenvolvidas pela Microsoft, é que cada framework é disponível com um modelo
de programação, para cada framework é necessário o esforço do aprendizado
específico e muitas vezes é necessário utilizar várias dessas tecnologias no mesmo
software, aumentando assim sua complexidade, além de todos esses frameworks
serem restritos para Windows.
Para solucionar o problema de muito esforço gasto no aprendizado de
várias tecnologias, a Microsoft unificou todas essas tecnologias em uma só, criando
o Windows Communication Foundation, onde tem como o grande slogan “Apenas
uma forma de escrever o código, mas várias maneiras de conectar os pontos”, ou
seja, codifique uma vez, e se comunique em vários padrões de comunicação.
Lowi (2010) define WCF como um kit de desenvolvimento de software para
desenvolvimento e implantação de serviços para hospedagem na plataforma
Windows, o WCF oferece um ambiente de execução para seus serviços e toda a
vantagem da Common Language Runtime (CLR) para troca de informações entre
serviços para plataforma Windows.
O WCF fornece um completo ambiente de desenvolvimento para aplicações
baseadas na arquitetura SOA, aumentando a produtividade, principalmente porque
é necessário somente um esforço de aprendizagem.
O WCF implementa um conjunto de padrões definidos pela indústrias para
definição de serviços, como tipo de conversões e serialização e gerenciamento de
protocolos, alcançando a interoperabilidade entre serviços.
O primeiro release do WCF foi lançado como parte do .NET framework 3.0,
onde disponibilizou muitas facilidades para criação de serviços, como hospedagem,
gerenciamento da instância do serviço, chamadas assíncronas, confiabilidade,
gerenciamento de transações, fila de chamadas desconectadas e segurança. O
segundo release de WCF foi lançado como parte do .NET framework 3.5,
fornecendo ferramentas adicionais estendendo as funcionalidades do framework
anterior e adicionando novas opções de comunicação. O último release e o mais
atual faz parte do .NET framework 4.0, incluindo mudança de configuração, algumas
extensões e novas características de revelação de serviços e rotas.
Lowi (2010) define serviço como uma funcionalidade exposta para o mundo
e que uma aplicação orientada a serviço agrega dentro de um serviço uma única
lógica da aplicação conforme a Figura 3.
Figura 3: Uma aplicação orientada a serviço.
Fonte: Lowi, 2010, p. 2.
Os serviços podem ser hospedados localmente ou remotamente,
desenvolvidos por mais de uma equipe e independente de tecnologia. O serviço
encapsula linguagem, tecnologia, plataforma, versão e frameworks, tendo que
somente obedecer aos padrões de comunicação permitidos.
Para consumir um serviço, o aplicativo cliente pode ser literalmente
qualquer tipo de aplicação, por exemplo, um Windows Forms, Windows
Presentation Foundation, Silverlight, uma página ASP.NET, ou qualquer outro
cliente. A comunicação entre clientes e serviços é feita por envio e recebimento de
mensagens. Com o WCF, mensagens são na maioria das vezes SOAP.
Essas mensagens são independentes de protocolos de transporte
diferentemente de web services, que são restritos ao protocolo HTTP. Aplicativos
cliente WCF podem se comunicar com serviços que não sejam codificados em
WCF, e serviços WCF podem interagir com aplicativos clientes não WCF. Caso
ambos os aplicativos cliente e servidor forem desenvolvidos em WCF, é possível
tirar vantagem específicas da plataforma .NET, obtendo maior performance.
Segundo Lowi (2010), em WCF, o cliente nunca se comunica diretamente
com o serviço, é criado um proxy que encaminha as requisições para o serviço e
expõe as mesmas operações do serviço além de alguns métodos de gerenciamento
do proxy.
As IDEs como Visual Studio e NetBeans geram o proxy automaticamente,
devido ao fato de que os web services são capazes de gerar o documento Web
Services Description Language (WSDL) que segundo Sharp (2010) é um arquivo
puro XML que descreve as mensagens que o web service pode receber e a
estrutura das respostas que o web service envia para a aplicação cliente.
O aplicativo cliente pode consumir um serviço WCF em qualquer ambiente
que esteja sendo executado, localmente, entre domínios ou remotamente conforme
Figura 4.
Figura 4: Comunicação WCF.
Fonte: Lowi, 2010, p. 4.
Lowi (2010) define que um serviço WCF constitui de cinco partes
fundamentais, address, contract, hosting, bindings e endpoint.
O endereço oferece duas características importantes: a localização do
serviço e o protocolo comunicação e tem o seguinte formato: [endereço base]/[URI
opcional], por exemplo: http://localhost:8001; http://localhost:8001/MeuServico.
O contrato descreve o que um serviço é capaz de fazer. O WCF possui
quatro tipos de contratos:
service contracts: define quais operações o cliente pode efetuar no
serviço;
data contracts: define os tipos de dados para a comunicação com o
serviço;
fault contracts: define quais erros são gerados pelo serviço e como é
disparado esse erro para o cliente;
message contracts: permite interação com serviço diretamente com
mensagens, podendo atribuir informações no cabeçalho SOAP.
O hosting é onde o serviço será hospedado, podendo ser no Internet
Information Services (IIS), no Windows Activation Service (WAS) para Windows
Vista ou Windows Server 2008, ou no Windows Server AppFabric para Windows 7,
ou até mesmo em qualquer aplicação .NET.
O binding do WCF é responsável pela configuração de transporte da
comunicação entre cliente e serviço, existem vários aspectos e padrões possíveis
de comunicação com um determinado serviço. As mensagens podem ser síncronas
ou assíncronas, bidirecional e armazenada em fila podendo ser durável ou volátil. A
Figura 5 mostra os tipos de bindings que WCF suporta.
Figura 5: Transporte e codificação para bindings.
Fonte: Lowi, 2010, p. 26.
A associação de um address que define onde o serviço está hospedado, um
binding que define qual meio de comunicação, e um contrato que define o que o
serviço faz é chamado de endpoint. O endpoint é a fusão entre address, contract e
binding, como mostrado na Figura 6.
Figura 6: Endpoint.
Fonte: Lowi, p. 29.
Lowy (2010) descreve que ao projetar um serviço, é necessário definir quais
tipos de endpoints especificamente o serviço será capaz de se comunicar, a
primeira questão é se o serviço WCF terá que se comunicar com clientes não WCF,
se sim, o protocolo de comunicação será o padrão para web services, o binding é do
tipo BasicHttpBinding, que expõe o serviço WCF para o mundo web como um web
service.
Se o cliente for um WCF e requer troca de mensagens offline ou
desconectado, o binding é do tipo NetMsmqBinding, que usa MSMQ como protocolo
de comunicação, se o cliente necessita de comunicação conectada e é WCF, o
binding é do tipo NetTcpBinding que é comunicação sobre TCP, e se o cliente
estiver na mesma máquina que o host do serviço, o binding pode ser do tipo
NetNamedPipeBinding, que usa o protocolo IPC para obter maior performance. A
Figura 7 apresenta um diagrama desse cenário.
Figura 7: Escolhendo um binding.
Fonte: Lowi, 2010, p. 27.
2.4 CONSIDERAÇÕES FINAIS
A UML cada vez mais está presente em empresas de desenvolvimento de
software, sendo utilizada por engenheiros, arquitetos e profissionais de software,
está na sua versão 2.0 e em breve será lançada a versão 3.0. Com a padronização
do vasto número de diagramas, é possível abstrair totalmente o projeto para os
envolvidos, desde o cliente até o desenvolvedor.
As empresas brasileiras de TI estão cada vez mais cientes de que SOA não
é somente uma aposta, e sim uma realidade e até mesmo uma necessidade, pois
os sistemas hoje estão exigindo cada vez mais integração e uma maior flexibilidade
em evolução e reutilização do software, e a proposta SOA é exatamente essa, evitar
a redundância e aumentar o ativo da empresa, pois obedecendo a essa arquitetura
e os padrões de comunicação, fica livre para empresa evoluir na tecnologia de
programação. Seu legado continuará funcionando, pois estão disponíveis através de
serviços e obedecendo aos padrões abertos de comunicação.
O WCF, que hoje é o padrão para desenvolvimento de serviços para
plataforma Windows, tem facilitado muito o desenvolvimento de software orientado a
serviço, com um padrão único de programação, é possível conectar de várias
formas, com vários serviços, independente de linguagem e plataforma.
3 ESTUDO DE CASO
O estudo de caso criado para essa monografia é um sistema de reserva de
salas para reunião e treinamento denominado WcfServicoReserva. Esse sistema foi
implementado em forma de serviço para utilização de SOA.
Cada colaborador que possui um login e senha pode solicitar a reserva de
uma sala conforme o seu nível, podendo ser diretoria, comercial ou colaborador
interno. Ao efetuar uma reserva o colaborador pode solicitar equipamentos, como
retroprojetor, televisão, notebook e dvd.
Para a modelagem do estudo de caso WcfServicoReserva foi utilizado a
ferramenta IBM Rational Rose, o primeiro passo foi a criação dos diagramas de
caso de uso, diagrama de classe e diagrama de sequencia, a Figura 8 ilustra o
diagrama de caso de uso.
Figura 8: Diagrama de Caso de Uso.
O próximo é o diagrama de classes, que representa as classes do sistema
conforme Figura 9.
Figura 9: Diagrama de Classes.
O próximo diagrama é o diagrama de sequência, que ilustra os passos do
colaborador para efetuar a reserva de uma sala conforme a Figura 10.
Figura 10: Diagrama de Sequência do Caso de Uso Efetuar Reserva.
Após a modelagem do sistema iniciou a implementação do serviço, que foi
desenvolvido utilizando a IDE Microsoft Visual Studio 2010.
O primeiro passo foi criar um projeto WCF conforme Figura 11.
Figura 11: Criar um projeto WCF no Visual Studio 2010.
Um programa WCF consiste no seguintes passos:
definir DataContracts;
definir o contrato do serviço;
implementar o contrato;
configurar endpoints;
hospedar o serviço.
3.1 DATACONTRACS
É a estrutura das mensagens que será transmitida pelo serviço, é
configurado no endpoint e pode ser tipada ou não tipada. Quando a mensagem é
não tipada é enviada a estrutura genérica do objeto que é compatível com qualquer
linguagem de programação, por exemplo int e string. Quando a mensagem é tipada
é enviado o próprio objeto .NET, o objeto é serializado e enviado a aplicação cliente,
esse tipo de configuração é somente para clientes desenvolvidos em WCF, que ao
receber a mensagem é feito a deserialização do objeto e é reconhecido o tipo e
convertido automaticamente. Nesse estudo de caso foi configurado os dois tipos de
envio de mensagem, tipado e não tipado.
A Figura 12 ilustra a classe Colaborador como DataContract.
Figura 12: Configurar uma classe para DataContract.
3.2 CONTRATO DO SERVIÇO
Define quais operações o serviço é capaz de executar, essas operações
são definidas em uma interface que será implementada para a criação do serviço.
Para cada operação do serviço é adicionado o atributo OperationContract, que diz
ao WCF que esse método será disponibilizado para o cliente fazer chamadas, e a
interface recebe o atributo ServiceContract, que diz ao WCF que a classe que
implementar essa interface será exposta como um serviço. A Figura 13 mostra a
interface definida para o serviço desse estudo de caso, contém cinco operações.
Figura 13: Contrato do serviço através de Interface.
3.3 IMPLEMENTAR O CONTRATO
Após criar a interface, é necessário criar uma classe para implementar a
interface do serviço. Na Figura 14, a classe ServicoReserva implementa o contrato
do serviço.
Figura 14: Codificação do serviço implementando a interface do serviço.
3.4 CONFIGURAR ENDPOINTS
Endpoint define as opções de comunicação do serviço, nesse estudo de
caso será de duas formas, basicHttpBinding que é a estrutura genérica para
interoperabilidade de tecnologias e netTcpBinding, binding específico para
aplicações .NET para troca de mensagens tipadas.
A configuração do endpoint pode ser feita de duas formas, via programação
ou no arquivo de configuração App.config, para esse estudo de caso foi utilizado a
configuração do endpoint via arquivo de configuração, que é simples e tem como
principal vantagem, caso necessite fazer alguma alteração no endpoint, não é
necessário recompilar o serviço.
Cada endpoint é composto de três partes, address, binding e contract.
Address é o endereço onde o serviço está hospedado, o binding é o tipo de
comunicação e o contract é a classe que implementa o serviço.
A Figura 15 mostra o arquivo de configuração do estudo de caso.
Figura 15: Arquivo App.config.
A primeira coisa a fazer é adicionar o serviço no arquivo de configuração
para que o WCF reconheça a classe que implementa o serviço, isso é feito através
da tag <service name="Namespace.NomeServico">. Após adicionar o caminho do
serviço é necessário informar o endereço base através da tag <baseAddress> que é
o endereço primário do serviço, e por último é configurado os endpoints do serviço.
Essas são as configurações necessárias para que o serviço possa ser consumido.
3.5 HOSPEDAR O SERVIÇO
É possível hospedar um serviço WCF em qualquer aplicação .NET ou no
Internet Information Services, servidor web da Microsft. Para esse estudo de caso,
foi hospedado dentro do próprio Visual Studio 2010, que ao executar o projeto abre
o Microsoft WCF Service Host, que é o host para serviços WCF conforme Figura 16.
Figura 16: Microsoft WCF Service Host.
A partir desse momento o serviço já está em funcionamento e pode ser
consumido, para visualizar as funcionalidades do serviço basta acessar o arquivo
WSDL que é gerado automaticamente pelo WCF, o arquivo WSDL especifica como
acessar o serviço e as operações disponíveis.
Para visualizar o arquivo WSDL gerado pelo WCF basta abrir em um
browser e digitar o endereço do serviço que nesse estudo de caso é
http://localhost/WcfServicoReserva?wsdl.
A Figura 17 mostra os metadados que descrevem o serviço
WcfServiçoReserva. Esse documento XML usa o WSDL schema e os elementos
descrevem as operações que o serviço WCF expõe. As operações são derivados
dos métodos definidos na interface IReserva e implementados na classe
ServicoReserva.
Figura 17: Arquivo WSDL.
As IDEs de desenvolvimento como Visual Studio e NetBeans conseguem
importar o arquivo WSDL para dentro da aplicação e automaticamente geram um
proxy local para disponibilizar as chamadas do serviço através de métodos dentro
da própria linguagem, a ferramenta faz uma leitura completa do arquivo WSDL e
gera uma biblioteca do serviço com todos os métodos disponíveis, a única
informação necessária é saber o endereço host do serviço.
Para testar o serviço criado, não é necessário criar um aplicativo cliente, ao
executar o serviço WCF o Visual Studio automaticamente disponibiliza uma
ferramenta de teste para testar o serviço, onde mostra o endereço do arquivo WSDL
conforme configuração no arquivo App.config. A Figura 18 ilustra a ferramenta de
teste do serviço embutido no Visual Studio.
Figura 18: Aplicativo de teste embutido no Visual Studio para teste do serviço.
Para cada binding configurado é disponibilizado a chamada de todos os
métodos do serviço conforme a Figura 18, onde mostra no quadro esquerdo as duas
interfaces de comunicação, a IReserva(BasicHttpBinding_IReserva) e a
IReserva(NetTcpBinding_IReserva), que permite testar o serviço através das duas
interfaces geradas conforme os bindings configurados.
Para efetuar a chamada de um método, de duplo click no método da
interface desejada e preencha os parâmetros do método caso necessário, a Figura
19 mostra um exemplo da chamada do método ValidarUsuario(), que utiliza o
padrão de comunicação aberto para interoperabilidade de tecnologias através da
interface IReserva(BasicHttpBinding_IReserva), o método ValidarUsuario() exige
dois parâmetros, login e senha, após informar login e senha clique no botão Invoke.
Figura 19: Chamada ao método ValidarUsuario().
Após clicar no botão Invoke para executar o método é possível visualizar a
estrutura da mensagem, tanto para envio como para recebimento transmitida em
formato XML SOAP. A seguir a Figura 20 apresenta um exemplo da chamada do
método ValidarUsuario() do serviço.
Figura 20: Visualização do envio e recebimento do método ValidarUsuario()
em formato SOAP.
Esse exemplo demonstra a chamada de um método de um serviço baseado
em arquitetura SOA, pois ele é capaz de ser descoberto através do endereço,
consumido independente de tecnologia e possui um contrato formal exposto através
do WSDL.
4 PERSPECTIVAS PARA TRABALHOS FUTUROS
O WCF é um framework para criação de serviços para plataforma Windows
que foi projetado para unificar e facilitar o desenvolvimento de sistemas distribuídos,
esse estudo de caso apresentou como ficou simples desenvolver um serviço em
WCF aderindo à arquitetura SOA.
Agora com o serviço hospedado, é necessário somente desenvolver um
aplicativo cliente para consumi-lo independente de linguagem e plataforma, pois
como apresentado nesse estudo de caso, o serviço WcfServicoReserva permite
conectar de duas formas, primeiro com os padrões pré-estabelecidos de
interoperabilidade de comunicação pela internet através de SOAP genérico e com
aplicativos clientes desenvolvidos em WCF, que utiliza SOAP binário aumentando a
performance de troca de mensagens entre serviço e cliente .NET.
Apesar das duas formas de comunicação utilizadas nesse trabalho, o
serviço foi desenvolvido utilizando somente um modelo de programação, sendo que
a única coisa necessária é configurar os bindings através do arquivo App.config,
lembrando que WCF permite uma série de configuração de bindings, conforme
descrito no capítulo 2 desse trabalho.
A fim de demonstrar o resultado e a aplicabilidade de SOA, é demonstrado
a seguir como consumir o serviço WcfServicoReserva em duas tecnologias
distintas, primeiro em .NET e posteriormente através da linguagem de programação
Java, sem necessidade nenhuma de alteração no serviço WcfServicoReserva
comprovando a interoperabilidade entre tecnologias.
Para demonstração de como consumir um aplicativo WCF na plataforma
.NET, foi criado um projeto do tipo ConsoleApplication conforme Figura 21.
Lembrando que e possível consumir um serviço WCF através de qualquer tipo de
aplicativo .NET tais como, um site ASP.NET, Windows Forms, Windows
Presentation Foundation, ConsoleApplication etc.
Figura 21: Criação do projeto do tipo ConsoleApplication para consumir o
serviço WcfServicoReserva.
Após criar o projeto, é necessário adicionar a referência do serviço
WcfServicoReserva que será consumido, para isso clique com o botão direito nas
referências do projeto e selecione a opção Add Service Reference, conforme a
Figura 22.
Essa tela pede o endereço do arquivo WSDL do serviço para que seja
gerado o proxy de comunicação com o serviço.
O endereço do WSDL é informado no campo Address que para esse estudo
de caso é o http://localhost:8085/WcfServicoReserva?wsdl, após informar o
endereço e clicar no botão Go, caso o endereço esteja correto o serviço é
descoberto e automaticamente é identificado o nome da classe do serviço
(ServicoReserva) e a interface de comunicação (IReserva) com todas as operações
disponíveis do serviço conforme Figura 23.
.
Figura 22: Adicionando a referência do serviço WcfServicoReserva.
Figura 23: Informando o endereço do arquivo WSDL do serviço
WcfServicoReserva.
Após clicar em ok é gerado automaticamente o proxy baseado nos
metadados do arquivo WSDL e adicionado a referência do serviço conforme Figura
24.
Figura 24: Referência do serviço WcfServicoReserva adicionada ao projeto.
Depois de adicionado a referência é possível testar o serviço, a Figura 25
demonstra a codificação da chamada do método ListarSalas() do serviço
WcfServicoReserva, para cada objeto Sala contido na lista retornada é impresso o
nome no console.
Figura 25: Chamada ao método ListarSalas() do serviço WcfServicoReserva.
A Figura 26 mostra o resultado da chamada do método, onde imprime o
nome das salas retornadas pelo serviço.
Figura 26: Resultado do método ListarSalas() do serviço WcfServicoReserva.
Foi demonstrado como é simples a comunicação com o serviço WCF
através de uma aplicação .NET, agora será demonstrado na linguagem Java a
chamada do mesmo método do serviço WcfServicoSala para a demonstração da
utilização de padrões abertos de comunicação pela internet que garantem a
interoperabilidade de tecnologias.
Para a criação do aplicativo cliente em Java foi utilizado a IDE NetBeans, os
passos a seguir são bem parecidos com o exemplo anterior.
Foi criado um projeto do tipo Aplicativo Java para a demonstração da
comunicação com o serviço conforme Figura 27.
Figura 27: Criação projeto do tipo Aplicativo Java para consumir o serviço
WcfServicoReserva.
Após criar o projeto, é necessário adicionar a referência do serviço
WcfServicoReserva que será consumido, para isso clique com o botão direito no
projeto, escolha a opção novo Cliente para serviço Web conforme Figura 28.
Figura 28: Criar um Cliente para serviço web para consumir o serviço
WcfServicoReserva.
Essa tela pede o endereço do arquivo WSDL do serviço para que seja
gerado o proxy de comunicação com o serviço. O endereço do WSDL é informado
no campo WSDL URL conforme Figura 29.
Figura 29: Informando o endereço do arquivo WSDL do serviço
WcfServicoReserva.
Após informar o endereço e clicar no botão finalizar é gerado o proxy de
comunicação com o serviço, a Figura 30 mostra a referência gerada para o serviço
e as duas interfaces de comunicação conforme o endpoint configurado no serviço
WcfServicoReserva. Para a comunicação com outras tecnologias que não são .NET
obrigatoriamente a comunicação é feita através da interface
BasicHttpBinding_IReserva, que é o padrão SOAP de comunicação para
interoperabilidade de tecnologias.
A Figura 31 demonstra a codificação em Java para comunicação com o
serviço.
Figura 30: Referência do serviço WcfServicoReserva adicionada ao projeto.
Figura 31: Chamada ao método ListarSalas() do serviço WcfServicoReserva em
Java.
E a Figura 32 demonstra o resultado da chamada do método ListarSalas(), o
resultado é o mesmo que no exemplo anterior.
Figura 32: Resultado do método ListarSalas() do serviço WcfServicoReserva
implementado em Java.
5 CONSLUSÃO
Esse trabalho teve como tema demonstrar a aplicação da arquitetura
SOA utilizando o framework WCF, onde demonstrou a evolução da tecnologia
Microsoft para sistemas distribuídos, desde o COM, passando pela sua evolução
através do DCOM e COM+, e após o desenvolvimento da plataforma .NET com o
Enterprise Services e .NET Remoting. A partir do framework .NET versão 3.5, foi
lançado a unificação de todas essas tecnologias anteriores e a Microsoft nomeou de
WCF.
O WCF tornou-se o padrão de desenvolvimento de sistemas distribuídos da
Microsoft, pois facilitou o desenvolvimento de serviços para troca de informações
estruturadas em uma plataforma descentralizada e distribuída, utilizando os padrões
abertos de comunicação para interoperabilidade de tecnologias através do protocolo
SOAP, que é o padrão aberto de comunicação recomendado pela W3C para
sistemas disponibilizados como serviços na internet.
Com o objetivo de testar a arquitetura SOA na plataforma Windows, foi
desenvolvido um estudo de caso em WCF denominado WcfServicoReserva,
onde disponibilizou comunicação através dos padrões abertos de comunicação
utilizando protocolo SOAP/HTTP e através do padrão proprietário da Microsoft para
WCF, que é um SOAP binário para comunicação entre aplicações cliente e servidor
desenvolvidos em WCF, obtendo alta performance através do protocolo TCP/IP.
Com o objetivo de demonstrar a interoperabilidade de tecnologias, foi
desenvolvido dois aplicativos clientes para consumir o serviço WCFServicoReserva,
o primeiro em WCF utilizando o protocolo SOAP binário e o segundo na linguagem
Java, utilizando o protocolo SOAP padrão para comunicação pela internet
Para os dois aplicativos clientes o resultado foi o mesmo, nas duas versões
é importado o arquivo WSDL do serviço WcfServicoReserva e é gerado um proxy de
comunicação com todos os métodos disponíveis para efetuar as chamadas das
operações do serviço.
WCF gerencia a forma de comunicação através dos bindings configurados
no arquivo App.config, cada aplicativo cliente desenvolvido nesse trabalho conectou
em um binding distinto, o primeiro desenvolvido em .NET conectou no
NetTcpBinding, e o segundo, que foi desenvolvido em Java conectou no
BasicHttpBinding.
Conforme o binding configurado o WCF gerencia a forma de comunicação,
e essa é a grande vantagem do WCF, várias formas de comunicação, mas somente
uma forma de implementação.
REFERÊNCIAS
ERL, Thomas. SOA: Principles of Service Design. Boston: Prentice Hall, 2008.
______. Service-Oriented Architecture: Concepts, Technology, and Design.
Boston: Pearson Education, Inc, 2009.
ERL, Thomas; KARMARKAR, Anish; WALMSLEY, Priscilla; HAAS, Hugo;
YALCINALP, Umit; LIU, Canyang Kevin, ORCHARD, David; TOST, Andre; PASLEY,
James. Web Service Contract Design and Versioning for SOA. Boston: Prentice
Hall, 2009.
FOWLER, M. UML Essencial: Um Breve Guia para a Linguagem-Padrão de
Modelagem de Objetos. 3. Ed. Porto Alegre: Bookman, 2005.
GIL, Carlos. Como elaborar projetos de pesquisa. São Paulo: Atlas, 1995, p.45 e 50.
LEITE, Francisco Tarciso. Metodologia científica: métodos e técnicas de
pesquisa: monografias, dissertações, teses e livros. Aparecida, SP: Idéias &
Letras, 2008.
LOWY, Juval. Programming WCF Services Third Edition. Sebastopol: O'Reilly
Media, Inc, 2010;
SHARP, John. Windows Communication Foundation 4 Step by Step.
Sebastopol: O’Reilly Media, Inc, 2010;
Service-Oriented Architecture. <http://whatissoa.com>. Acesso em 10/01/2012.
