Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login

Desenvolvendo e Usando Web Services em Java

Veja neste artigo como criar um Web Service baseado em SOAP, como podemos publicá-lo em um servidor e como utilizar este Web Service.

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login

(opcional) Onde podemos melhorar?

Confirmar voto
0
 (1)  (0)

Os Web Services podem ser baseados no protocolo SOAP ou no estilo REST (chamados de RESTful). Ambos funcionam sob o protocolo HTTP, que é o protocolo padrão de transferência de documentos na Web.

SOAP é um dialeto XML utilizado para descrever mensagens que são trocadas entre componentes SOA (Service Oriented Architecture).

No restante do artigo veremos como criar um Web Service ao estilo SOAP.

saiba mais Saiba mais sobre os Web Services REST x SOAP

Criando Web Services em SOAP

Em Java, os serviços Web são definidos por classes. Um Web Service pode oferecer várias operações, representada por um método de classe. Uma prática muito importante de ser seguida é sempre dividirmos a interface de um serviço da sua implementação. A interface de um serviço é chamada de SEI (Service Endpoint Interface) e a implementação é chamada de SIB (Service Implementation Bean).

Neste exemplo usaremos o bloco de notas para entendermos melhor tudo o que acontece, diferente de utilizar um ambiente de desenvolvimento que muitas vezes abstraem diversos detalhes que deveriam ser implementados.

Vamos iniciar a implementação criando um Web Service simples separada em SEI e SIB que possui quatro operações: “soma, subtracao, divisao, multiplicação”. O objetivo deste serviço é retornar o calculo de uma das operações invocadas pelo cliente. Segue abaixo o exemplo do SEI para o nosso serviço de calculadora. Salve o arquivo abaixo com o nome CalculadoraServer.java dentro de uma pasta "calc".

package calc;

import javax.jws.WebService;
import javax.jws.WebMethod;
import javax.jws.soap.SOAPBinding;
import javax.jws.soap.SOAPBinding.Style;

@WebService
@SOAPBinding(style = Style.RPC)
public interface CalculadoraServer {
	@WebMethod float soma(float num1, float num2);
	@WebMethod float subtracao(float num1, float num2);
	@WebMethod float multiplicacao(float num1, float num2);
	@WebMethod float divisao(float num1, float num2);
}
Listagem 1. Interface para o serviço de calculadora.

Não há nada de muito diferente em relação a um código qualquer normal de interface Java. Porém notamos que as @WebService, @WebMethod e @SOAPBinding provavelmente são novidades para aqueles que ainda estão aprendendo sobre Web Services. @Webservice é uma anotação que avisa ao compilador Java que o arquivo atual corresponde à definição SEI de um serviço Web.

@WebMethod indica que um determinado método corresponde a uma operação de serviço e assim pode ser invocado por um cliente. @SOAPBinding indica que o serviço utilizará a abordagem SOAP e não Rest que é a outra abordagem suportada.

Agora que a interface está criada e anotada corretamente vamos criar a implementação da interface, ou seja, a nossa SEI onde serão implementados os métodos definidos anteriormente. Para isso precisamos criar a classe CalculadoraServerImpl.java que estará salvo dentro da pasta calc. Segue abaixo a implementação:

package calc;

import java.util.Date;
import javax.jws.WebService;

@WebService(endpointInterface = "calc.CalculadoraServer")
public class CalculadoraServerImpl implements CalculadoraServer {
		
	public float soma(float num1, float num2) {
		return num1 + num2;
	}
	
	public float subtracao(float num1, float num2) {
		return num1 - num2;
	}

	public float multiplicacao(float num1, float num2) {
		return num1 * num2;
	}

	public float divisao(float num1, float num2) {
		return num1 / num2;
	}

}
Listagem 2. Implementação da interface do serviço.

A listagem acima nada mais é do que uma implementação de uma classe como outra qualquer com os métodos da interface descritos e implementados. No entanto, neste código temos uma novidade, a propriedade endpointInterface dentro da anotação @WebService.

Essa propriedade faz com que a classe atual, a SIB, ligue-se com a SEI especificada anteriormente (calc.CalculadoraServer).

Agora tudo que nos resta é compilar este arquivo. Para isso podemos utilizar o terminal acessando o Prompt de Comando no menu de programas do Windows ou o Terminal do Linux. No Prompt entre na pasta onde os arquivos anteriores foram salvos (entre na pasta onde a pasta calc foi criada, ou seja, um nível acima da pasta calc), por exemplo:

cd "C:\Users\higor\Desktop\Exercicios"

e execute o comando:

javac calc/*.java

Se não ocorrer nenhum erro tudo foi corretamente criado e os .class relativo a cada um dos arquivos foi criado na pasta calc. Se ocorrer algum erro veja se não houve nenhum erro de digitação e se a variável JAVA_HOME foi corretamente especificada.

Agora estamos prontos para publicar o serviço e isso será discutido na próxima seção do artigo.

Publicando o Serviço

Agora que os arquivos já foram compilados podemos publicá-lo. Para isso precisamos gerar o arquivo abaixo CalculadoraServerPublisher.java dentro da pasta calc juntamente com os arquivo definidos anteriormente.

package calc;

import javax.xml.ws.Endpoint;

public class CalculadoraServerPublisher {

	public static void main(String[] args)
	{
		Endpoint.publish("http://127.0.0.1:9876/calc",
		new CalculadoraServerImpl());
	}
}
Listagem 3. Publicando o serviço.

Neste código percebe-se o uso da classe Endpoint que está disponível na linguagem Java e que nos permite publicar um serviço em um servidor. Para que possamos usa-la deve-se passar como parâmetro o endereço do servidor e a instância do SIB do serviço a ser publicado. Notamos que o serviço é publicado na porta 9876.

Agora basta compilar o arquivo anterior com o comando:

javac calc/CalculadoraServerPublisher.java

Por fim, podemos executa-lo através do comando:

java calc.CalculadoraServerPublisher

Para verificarmos se tudo foi publicado corretamente basta acessar no browser o link: http://127.0.0.1:9876/calc?wsdl

Se tudo ocorrer perfeitamente poderemos visualizar o WSDL do serviço publicado. Com isso estamos prontos para usar o serviço.

Usando o Serviço

Agora que o serviço está publicando, executando e pronto para ser usado, vamos criar um cliente que acessará o Web Service criado anteriormente. O código abaixo demonstra um cliente para o nosso Web Service:

package calc;

import javax.xml.namespace.QName;
import javax.xml.ws.Service;
import java.net.URL;

class CalculadoraClient {

	public static void main(String args[]) throws Exception {
		URL url = new URL("http://127.0.0.1:9876/calc?wsdl");
		QName qname = new QName("http://calc/","CalculadoraServerImplService");
		Service ws = Service.create(url, qname);
		CalculadoraServer calc = ws.getPort(CalculadoraServer.class);

		System.out.println("Soma (5+1): " + calc.soma(5,1));
		System.out.println("Subtracao (5-1): " + calc.subtracao(5,1));
		System.out.println("Multiplicacao (5*1): " + calc.multiplicacao(5,1));
		System.out.println("Divisao (5/1): " + calc.divisao(5,1));

	}
}
Listagem 4. Cliente para o Web Service.

Neste código pode-se observar que necessitamos passar o endereço do WSDL para a URL, indicando onde o WSDL do serviço poderá ser encontrado. Na segunda linha passamos um nome qualificado em XML para QName. Ele indica uma URI (namespace) e o nome do serviço. O namespace é fornecido pela WSDL do serviço, e o nome local é a classe SIB acrescida da palava “Service”. O nome local aparece na última seção do documento WSDL (seção service).

Por fim, na linha “Service ws = ws.create(url, qname)“ temos como retorno uma referência a um objeto que pode invocar as operações oferecidas pelo serviço (em portType) e na próxima linha finalmente acessamos a interface de ponto final (endpoint) do calc.CalculadoraServer, que é tipo SEI do serviço, sendo capaz de acessar seus métodos.

Agora simplesmente compilamos este arquivo e executamos abrindo um novo Prompt de Comando, já que no outro Prompt estamos com o arquivo de publicação rodando.

Executando com o comando abaixo:

java calc.CalculadoraClient

Temos os resultados abaixo:

Soma (5+1): 6.0
Subtracao (5-1): 4.0
Multiplicacao (5*1): 5.0
Divisao (5/1): 5.0

Pode-se verificar que o cliente acessou o Web Service passando alguns parâmetros e obteve determinados resultados. Lembramos que este cliente poderia ter sido implementado em qualquer linguagem de programação como C, C++, PERL entre diversas outras.

Neste artigo estudamos como desenvolver um Web Service em Java e publicamos o serviço em um servidor Local. Verificamos cada uma das linhas de código criadas e o que significa cada uma das anotações utilizadas. Por fim, desenvolvemos um cliente em Java que utiliza o serviço que criamos anteriormente passando parâmetros e recebendo os resultados esperados.

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Ajude-nos a evoluir: você gostou do post?  (1)  (0)

(opcional) Onde podemos melhorar?

Confirmar voto
Compartilhe:
Ficou com alguma dúvida?