Implementando um Serviço com SOAP, (HTTP e XML).
Tags: soap, webservice, java, servicesoap
Published: 2021-10-29 20:59:04


## Implementando um Serviço com SOAP, (HTTP e XML).

**Bom, já que estamos aqui que tal batermos um papo?**

Então, lembrando que esse artigo curto e prático é uma extensão do artigo anterior onde iniciamos nossos trabalhos sobre “SOAP”, nele falamos mais sobre a especificação JAX-WS, volta um pouco a fita e caso não tenha lido volta lá pois é muito importante essa leitura antes de colocar a mão nessa implementação aqui com SOAP.

![](https://cdn-images-1.medium.com/max/2560/1*wP3_SRIkmtzwKMK0A1v8-g.jpeg)

***Let´s Go…***

![](https://cdn-images-1.medium.com/max/2000/0*jQJp2ioJqWGJBd_y)

**Simbora para os requisitos**, rsrsr…. O quêeeee?😱 Você não estava querendo colocar logo a mão no código sem saber dos requisitos correto? rsrsrs Esse é um vício de muitos de nós, inclusive meu, negligenciar os requisitos e partir logo para o “código”.

**PS:** Já tenho uma aplicação simples feita na especificação **Java EE**(geralmente é o padrão das aplicações que usam service soap), front bem simples com **Primefaces**, mas isso não é importante, afinal vamos tratar de um serviço, essa aplicação está sendo deployada no middleware **WildFly 20**, e bd **PostgresSQL** 13, vou deixar o link do repo desse (app) também, aaa já iria esquecendo JDK 8, e minha IDE favorita Eclipse, versão **Eclipse IDE for Java EE Developers**, também vamos precisar de um client Soap para fazer os testes, vou usar o **Soap UI** por já ter bastante familiaridade com o mesmo, por ser um dos mais famosos no mundo Java, você pode usar outro se quiser inclusive qualquer versão até o seguinte presente.

Nesse processo vamos vê algumas classes e XML, na época a grande proposta era criar um meio de integração que não necessitasse ser desenvolvido um novo protocolo, isso estava fora de questão, foi então que surgiu a ideia de usar Http com XML e nasceu o **SOAP**.

## Vamos entender melhor sobre o SOAP!

**Comunicação entre sistemas**, essa foi a principal motivação para a criação do **SOAP** que quer dizer no nosso bom portuga, Protocolo de Acesso a Objetos Simples, a exemplo: recentemente atuei em um projeto onde a empresa em questão tem um grande sistema que faz uma determinada coisa, (já tem regras de negócios bem definidas lá) e por meio de um, **Web Service** seguindo a especificação [**JAX-WS**](https://dev.to/gabrielsantosba/jax-ws-a-api-coroa-do-java-introducao-ao-soap-1hed) então e disponibilizado um serviço para os clientes poderem acessar esse grande sistema e assim poder usar dessas regras de negócios que já existe la, assim facilitando mão de obra tempo dinheiro e tudo mais, isso é possível também graças a implementação **SOAP**, que disponibiliza uma definição onde os sistemas externos irão saber quais métodos chamar(requisitar) para cada determinada ação que precisem.

**É isso que vamos fazer nesse atrigo disponibilizar um serviço com SOAP. 
Vem comigo, colocar mão na massa!**

**Zoom-in:** lembrando que você pode usar uma aplicação que já tenha ai para esse exemplo.

### Criando o Primeiro Serviço com SOAP.

![](https://cdn-images-1.medium.com/max/2000/0*LE6CfFAlC3yBkUE6)

Temos então a classe em questão “Alunos” expressivamente coloquei no pacote **ServicoSOAP**, nos sistemas das empresas em geral, fica apenas no pacote de serviço, lá tem cada classe referente a cada serviço.

Bom, mas vamos falar da nossa classe, a anotação mais importante encontra-se na linha 16, bastaria ela para eu dizer tenho um **@WebService** anotação essa do pacote **javax.jws.WebService**, essa anotação então irá fornecer o contrato que precisamos para poder ter acesso ao nosso serviço através de um client, a mesma irá fazer com que nosso método entenda que deve trabalhar com **HTTP** e **XML**, esse contrato que citei acima chama-se **WSDL**, vamos falar sobre ele mais a baixo, por hora vamos voltar a nossa classe que representa então nosso serviço **Alunos**. (Sobre as anotações **@Webresult**, e **@WebMethod**, não se preocupem elas servem apenas para deixar o resultado final do XML mais digamos assim amigável). Vou deixar links para estudos sobre no fim deste post.

Da linha 20 até a linha 25 trata-se apenas de código necessário para a parte de persistência funcionar corretamente, temos ali o famosíssimo **EntityManager**, **Dao** e etc.

**Indo ao que interessa:** Deixe eles lá, concentre-se nas linhas 27 a 38, pois aqui onde definimos então 2 métodos que serão disponibilizados através do nosso serviço que estamos desenvolvendo, simples assim, somente com essas linhas nós já definimos nosso **Web Service** com **SOAP**, já temos um contrato, e com isso temos também dois métodos que podem ser acessados de forma externa e retornam dados de nossa aplicação.

**Uauuuu…. melhor que isso só um HelloWord rsrsr** 😎

Agora precisamos publicar nosso **Web Service**, para isso temos que definir em qual **URL** ele ficará disponível e bem como também quais os tipos de retorno (Classe de Implementação) que ele deverá entender.

*Não conta para ninguém mas… Isso é absurdamente simples de se fazer. Simbora!*🥳

## Publicando Nosso Serviço com SOAP.

![](https://cdn-images-1.medium.com/max/2000/0*RrmpsiAu-RfmwhYP)

Temos então a classe em questão **PublishServiceAlunos**, também no pacote **ServicoSOAP**, essa classe tem um método **main**, (não estamos usando Spring rsrsr), e dentro desse método então na linha 9 estou definindo o tipo de implementação que esse **endpoint** irá trabalhar(retornar) e também a URL que ele deve usar para publicar, na linha 13 então usando a classe do [**JAX-WS**](https://dev.to/gabrielsantosba/jax-ws-a-api-coroa-do-java-introducao-ao-soap-1hed), classe **Endpoint**, que tem o método **publish**, método esse que recebe dois parâmetros, a **URL** e a **classe de implementação**.

**Voilà:** Simples assim está pronto, já temos um serviço com **SOAP** publicado e prontinho para ser acessado por terceiros, quartos e quintos etc. kkk.

![](https://cdn-images-1.medium.com/max/2000/0*sTMNf8FhEvEYX2JB)

Se ligou? Não é muito simples, agora vamos ao que interessa né, testar tudo isso, afinal ***não tá pronto até ser testado.***

## **Antes Vamos Olhar o Contrato? WSDL.**

Como citei rápido acima, precisamos de um contrato para que aplicações externas possam acessar esse nosso serviço, nas integrações mais modernas de hoje em dia seria como a *url de uma api, *a grosso modo falando**kk, esse contrato e definido por uma carinha que e o **WSDL(Web Services Description Language)**, como o próprio nome sugere esse e o cara que descreve como aquele web service deve ser acessado, em sua assinatura podemos observar que ele tem bastante “coisas”, tudo definições, não se preocupe com isso agora, basta saber que dessa forma os clientes externos saberão qual método deve ser chamado para determinada situação, assim nossa aplicação recebe essa requisição naquele método específico, levanta(invoca) um [servlet](https://dev.to/gabrielsantosba/servlets-quem-sao-onde-vivem-como-usar-4lb6), então aciona o método chamado trazendo o retorno solicitado.

**Zoom-out**: Você pode se perguntar por que não usar JSON? Por que como falamos acima essa estratégia de integração foi criada na época onde o rei era o XML, foi antes de o JSON fazer sucesso.

**Agora Vamos Testar.**

Como falei acima estou usando middleware **WildFly**, porquê? Eu gosto dele, mas vc pode usar qualquer outro, saliento ainda que esse exemplo pode ser feito com uma aplicação Spring, lembre-se que nesse caso deve colocar no pom a dependência do javax referencia **jsr250-api**, siga-me, subindo o WildFly aqui…

![](https://cdn-images-1.medium.com/max/2000/0*YorbiN_KaVTzB-Cu)

Aqui no meu console lindo ele já me mostra algumas informações referentes ao serviço que acabei de criar, perceba no parâmetro **address** a **url** que definimos na classe **PublishServiceAlunos**. Vou copiar e jogar ela no browser!

![](https://cdn-images-1.medium.com/max/2000/0*YyUcMVC5Vge8qz89)

### Joguei no browser e deu ruim, o que será?

Bom um serviço **SOAP** deveria ser usado sempre com o protocolo Http do tipo **POST**, toda via jogando direto no browser por padrão e feito um **GET** a mensagem de erro é clara, *HTTP GET não é compatível*, agora entra em cena nosso client soap, o Soap UI, nele poderemos baixar o contrato(**WSDL**) e com isso o mesmo irá reconhecer os métodos que temos para esse endpoint no **Web Service** em questão.

***Mas Antes Como Acessar o Contrato, Onde Fica Isso?***

Bom na (**URL**) que definimos eu havia dito que ali já teríamos um contrato e não foi mentira, porem por convenção para acessarmos esse contrato devemos adicionar ao fim da **URL**o seguinte parâmetro: **?wsdl”**.

**ex:** [http://localhost:8080/Academax/AlunosAcademia?wsdl](http://localhost:8080/Academax/AlunosAcademia?wsdl)

Agora indo no Browser novamente temos acesso ao contrato do nosso serviço, perceba que os métodos que criamos também estão descritos lá, e assim que as aplicações externas acessam nosso **Web Service**, o **WSDL** fornece as informações importantes para quem externo for acessar aquele determinado **endpoint**.

![](https://cdn-images-1.medium.com/max/2000/0*22G8R3ePbH_DkBTC)

### Bom ta ficando quente em…

Agora vamos jogar no SoapUI nosso client soap e fazer um teste mais concreto.

![](https://cdn-images-1.medium.com/max/2000/0*kYN41hlsYo8xubvU)

Clicando na opção **SOAP**

![](https://cdn-images-1.medium.com/max/2000/0*jxRQcSP66sIK382I)

Temos acesso a essa telinha, no campo Initial WSDL, será onde nós vamos colocar nossa (URL), poderíamos também procurar o arquivo WSDL baixado, alguns casos é enviado apenas o arquivo ao cliente para ele poder ter acesso aos recursos do endpoint em questão.

![](https://cdn-images-1.medium.com/max/2000/0*oTGegL4fD7oYevID)

Jogando a URL no Soap Ui, ele já reconhece o nome do **Web Service** e agora e só da um velho e bom OK.

Após isso olha que coisa magica, lembra os dois métodos que eu havia descrito na classe Alunos? Então…

![](https://cdn-images-1.medium.com/max/2000/0*gA4B0x9Asxn_I1QE)

Olha os bonitinhos ai, com suas devidas requests prontas só precisando apertar um play para funcionar.

![](https://cdn-images-1.medium.com/max/2134/0*npGQNeITf4Z1uDHs)

Olha ali o método **TodosAlunos**, esse responsável por trazer todos os alunos cadastrados na base, vamos testar, vamos aperta o play que está ali encima aquele “verdinho” e vê se pega fogo.

![](https://cdn-images-1.medium.com/max/2144/0*0IIcDY790jGOJRPi)

**Pegou fogo mesmo rsrsr**, retornou bonitinho da base, ou seja, nosso serviço está **Ok**, funfando, retornou o XML com as tags e dentro dela os dados, nesse caso cadastro de alunos que por sinal é tudo “Gabriel” rsrsr

Agora o método **buscarPorID,** esse necessita que seja passado um parâmetro dentro da tag arg0, caso eu quisesse deixar mais semântico, poderia usar a annotation @WebResult e especificar no parâmetro name = “id”.

***Vamos ao retorno.***

![](https://cdn-images-1.medium.com/max/2084/0*OGIh4xSc-WxWPOAT)

### Retorno:

![](https://cdn-images-1.medium.com/max/2080/0*yB4XPhfDRXJGfVHu)

Prontinho tudo lindo, com isso concluímos que o nosso **Web Service** está funcionando, claro tem mais algumas especificações algumas anotações que não falamos aqui, a exemplo a [@XMLElementRoot](https://docs.oracle.com/javase/7/docs/api/javax/xml/bind/annotation/XmlRootElement.html), a anotação [@WebResult](https://docs.oracle.com/javaee/5/api/javax/jws/WebResult.html), [@WebMethod](https://docs.oracle.com/javase/7/docs/api/javax/jws/WebMethod.html), essas duas ultimas servem para deixar mais bonitinho, personalizar o XML, nos links você pode se aprofundar.

### Que legal você que me acompanhou até aqui!

![](https://cdn-images-1.medium.com/max/2000/0*MnoovMBCbC2Ccd_v)

Aprendemos e falamos sobre uns assuntos da hora. Claro essa e uma implementação bem simplista, introdutoria, não tira a necessidade de estudos mais avançados, indico a [Alura, tem cursos completos para tal](https://www.alura.com.br/curso-online-web-services-soap?gclid=CjwKCAjwzt6LBhBeEiwAbPGOgSv6TRN1dLfZtSh2AVUEDVoy48VgPI_xmrO1EUuzVi0pzEUjzUDJoxoC-5MQAvD_BwE).

* Vimos que **Web Services** foram criados para integrar sistemas.

* Aprendemos também que o SOAP funciona com o XML e ali por baixo dos panos usa o protocolo Http.

* Descobrimos também sobre o contrato utilizado com **SOAP**o **WSDL**, que serve para descrever os métodos e os dados necessários para poder acessar um **Web Service**.

**Por enquanto é isso, vamos aos próximos episódios e não deixe de estudar, foco no foco e Deus te Abençoe!**