Introdução aos Web services

JAX-WS
 Java API para Web services XML (JAX-WS), JSR 224 é uma parte importante
das plataforma Java EE. Uma sequência da release da API Java para RPC 1.1
(JAX-RPC) com base em XML, o JAX-WS simplifica a tarefa de desenvolvimento
de Web services utilizando a tecnologia Java. Ela aborda alguns dos problemas
em JAX-RPC 1.1, fornecendo suporte a vários protocolos, como SOAP 1.1,
SOAP 1.2, XML, e fornecendo um recurso para dar suporte a protocolos
adicionais junto com HTTP. O JAX-WS usa JAXB 2.0 para vinculação de dados
e dá suporte a personalizações para controlar interfaces de ponto final de serviço
geradas. Com suporte a anotações, o JAX-WS simplifica o desenvolvimento do
Web service e reduz o tamanho de arquivos JAR do run-time.
Este documento demonstra os conceitos básicos sobre o uso do IDE para
desenvolver um Web service JAX-WS. Após criar o Web service, você escreve
três clientes de Web service diferentes que usam Web service em uma rede,
denominado "consumo" de um Web service. Os três clientes são uma classe
Java em uma aplicação Java SE, um servlet e uma página JSP em uma
aplicação Web. Um tutorial mais avançado que se concentra em clientes
é Desenvolvendo Clientes de Web Service JAX-WS.
Conteúdo

 Criando um Web Service

 Criando o Web Service
 Implantando e Testando o Web Service
 Amostras
 Consumindo o Web Service em
 uma classe Java em uma Aplicação Java SE
 um servlet em uma aplicação Web
 uma página JSP em uma aplicação Web
Para seguir este tutorial, são necessários os recursos e o software a
seguir.
Software ou Recurso Versão Necessária

NetBeans IDE Pacote de download do Java EE

JDK (Java Development Kit) JDK 7 ou JDK 8

GlassFish Server Open Source

Servidor de aplicações ou Web compatível
Edition
com Java EE
Oracle WebLogic Server

PÁGINA 1
Observação: o GlassFish Server pode ser instalado com a distribuição de Java
EE do NetBeans IDE. Como alternativa, você pode visitar a página de downloads
do GlassFish Server ou a página de downloads do Apache Tomcat.
Importante: os projetos Java EE requerem GlassFish Server ou Oracle
WebLogic Server 12c.
O servidor web de Tomcat incorporado não é um servidor web totalmente
compatível com Java EE. No entanto, o servidor web Tomcat 7.x pode ser
configurado para suportar alguma funcionalidade de Java EE. Consulte o Projeto
Apache para EE para obter informações sobre como adicionar suporte ao Java
EE para Tomcat.

Criando um Web Service

O objetivo deste exercício é criar um projeto apropriado para o conteiner de
implantação que você decidir utilizar. Uma vez criado o projeto, você irá criar
nele um Web service.
Escolhendo um Conteiner
Você pode implantar o Web service em um conteiner Web ou em um conteiner
EJB. Isso depende das suas escolhas de implementação. Se estiver criando
uma aplicação Java EE, use um conteiner Web, pois você pode colocar EJBs
diretamente em uma aplicação Web. Por exemplo, se você planeja implantar no
Servidor Web Tomcat, que tem somente um conteiner Web, crie uma aplicação
Web, não um módulo EJB.
1. Selecione Arquivo > Novo Projeto (Ctrl-Shift-N no Linux e no Windows,
⌘-Shift-N no MacOS). Selecione Aplicação Web na categoria Java Web
ou Módulo EJB na categoria Java EE.
Você pode criar um Web service JAX-WS em um projeto Maven.
Selecione Arquivo > Novo Projeto (Ctrl-Shift-N no Linux e no Windows,
⌘-Shift-N no MacOS) e o módulo Aplicação Web Maven ou Maven EJB
na categoria Maven. Se você nunca tiver usado Maven com NetBeans
antes, consulte Melhores Práticas para o Maven.
2. Nomeie o projeto CalculatorWSApplication. Selecione uma
localização para o projeto. Clique em Próximo.
3. Selecione o servidor e a versão do Java EE e clique em Finalizar.
Para usar o Oracle WebLogic server, registre o servidor no IDE. Além
disso, se você estiver usando o WebLogic server, observe a screencast
em Implantando uma Aplicação Web para Oracle WebLogic.
Criando um Web Service com base em uma Classe Java
1. Clique com o botão direito do mouse no
nó CalculatorWSApplication e selecione Novo > Web Service.
2. Chame o Web service de CalculatorWS e
digite org.me.calculator no Pacote. Deixe Criar Web Service do
Início selecionado.
3. Se você estiver criando um projeto Java EE em GlassFish ou WebLogic,
selecione Implementar Web Service como um Bean de Sessão Sem

PÁGINA 2
 Estado.

4. Clique em Finalizar. A janela Projetos exibirá a estrutura do novo Web

service e o código-fonte será mostrado na área do editor.

Adicionando uma Operação ao Web service

O objetivo deste exercício é adicionar ao Web service uma operação que
adiciona dois números recebidos de um cliente. O NetBeans IDE oferece uma
caixa de diálogo para adicionar uma operação a um Web service. Você pode
abrir essa caixa de diálogo no visual designer para Web service ou no menu de
contexto do Web service.
Advertência: o visual designer não está disponível em projetos Maven.
Para adicionar uma operação ao Web service:
1. Ou:

PÁGINA 3
 Altere a view do Design no editor.

Ou:
 Localize o nó do Web service na janela Projetos. Clique com o botão
direito do mouse no nó. Aparecerá um menu de contexto.

2. Clique em Adicionar Operação no designer visual ou no menu de

contexto. A caixa de diálogo Adicionar Operação será aberta.
3. Na parte superior da caixa de diálogo Adicionar Operação, digite add em
Nome e digite int na lista drop-down Tipo de Retorno.

PÁGINA 4
4. Na parte inferior da caixa de diálogo Adicionar Operação, clique em
Adicionar e crie um parâmetro de tipo int chamado i.
5. Clique novamente em Adicionar e crie um parâmetro de
tipo int chamado de j.
Agora você deverá ver o seguinte:

6. Clique em OK na parte inferior da caixa de diálogo Adicionar Operação.

Você retornará ao editor.
7. Remova a operação hello default deletando o método hello() no
código-fonte ou selecionando a operação hello no visual designer e
clicando em Remover Operação.
O visual designer agora exibe o seguinte:

PÁGINA 5
8. Clique em Código-Fonte e exiba o código que você gerou nas etapas
anteriores. Será diferente se você tiver criado o serviço como um bean
sem estado Java EE6 ou não. Você pode perceber as diferenças das
telas abaixo? (Um serviço Java EE 6 ou Java EE 7 que não é
implementado como bean sem estado parece um serviço Java EE 5.)

PÁGINA 6
PÁGINA 7
 Observação. No NetBeans IDE 7.3 e 7.4 você verá que na
anotação @WebService gerada, o nome do serviço é especificado
explicitamente:
@WebService(serviceName = "CalculatorWS").
9. No editor, estenda a operação de esqueleto add para o seguinte
(alterações em negrito):
10. @WebMethod
11. public int add(@WebParam(name = "i") int i,
@WebParam(name = "j") int j) {
12. int k = i + j;
13. return k;
}
Como você pode ver no código acima, o Web service simplesmente recebe dois
números e retorna a soma deles. Na próxima seção, você usa o IDE para testar
o Web service.

Implantando e Testando o Web service

Depois de implantado um Web service em um servidor, você poderá usar o IDE
para abrir o cliente de teste do servidor, caso ele tenha um cliente de teste. Os
servidores GlassFish e WebLogic oferecem clientes de teste.
Se você estiver usando o servidor Web Tomcat, não haverá cliente de teste.
Você só poderá executar o projeto e ver se a página de web services do Tomcat

PÁGINA 8
é aberta. Nesse caso, antes de executar o projeto, é preciso tornar o web service
o ponto de entrada da aplicação. Para tornar o web service o ponto de entrada
da aplicação, clique com o botão direito do mouse no nó do projeto
CalculatorWSApplication e selecione Propriedades. Abra as propriedades de
Executar e digite /CalculatorWS no campo URL Relativo. Clique em OK.
Para executar o projeto, clique com o botão direito do mouse no nó do projeto
novamente e selecione Executar.
Para testar a implantação bem-sucedida em um servidor GlassFish Server
ou WebLogic:
1. Clique com o botão direito do mouse no projeto e selecione Implantar. O
IDE inicia o servidor de aplicações, constrói a aplicação e a implanta no
servidor. Você pode acompanhar o progresso dessas operações no
CalculatorWSApplication (run-deploy) e nas guias do GlassFish Server ou
Tomcat na view Saída.
2. Na guia Projetos do IDE, expanda o nó Web Services do projeto
CalculatorWSApplication. Clique com o botão direito do mouse no nó
CalculatorWS e selecione Testar Web Service.

O IDE abrirá a página de teste em seu browser, se você tiver implantado

uma aplicação Web no GlassFish Server. Para o servidor Web Tomcat e
a implantação de módulos EJB, a situação é diferente:

PÁGINA 9
  Se você tiver implantado no GlassFish Server, digite dois números na
página de teste, como mostrado abaixo:

A soma dos dois números é exibida:

Amostras
Você pode abrir uma versão completa do bean sem estado Java EE do serviço
Calculadora selecionando Arquivo > Novo Projeto (Ctrl-Shift-N no Linux e no
Windows, ⌘-Shift-N no MacOS) e navegar até Amostras > Web Services Java >
Calculadora (EE6).
Um Serviço de Calculadora Maven e um Cliente de Calculadora Maven estão
disponíveis em Amostras > Maven.

Consumindo o Web Service

PÁGINA 10
Agora que você implantou o Web service, precisará criar um cliente para utilizar
o método add do Web service. Aqui, você cria três clientes — uma classe Java
em uma aplicação Java SE, um servlet e uma página JSP em uma aplicação
Web.
Observação: um tutorial mais avançado que se concentra nos clientes
é Desenvolvendo Clientes de Web Service JAX-WS.
Cliente 1: Classe Java na Aplicação Java SE
Nesta seção, você cria uma aplicação Java padrão. O assistente usado para
criar a aplicação também criará uma classe Java. Em seguida, você usa as
ferramentas do IDE para criar um cliente e consumir o Web service que criou no
início deste tutorial.
1. Selecione Arquivo > Novo Projeto (Ctrl-Shift-N no Linux e no Windows,
⌘-Shift-N no MacOS). Selecione Aplicação Java na categoria Java.
Nomeie o projeto CalculatorWS_Client_Application. Deixe a
opção Criar Classe Principal selecionada e aceite todas as outras
definições default. Clique em Finalizar.
2. Clique com o botão direito do mouse no
nó CalculatorWS_Client_Application e selecione Novo >
Cliente de Web Service. O assistente de Novo Cliente de Web Service
será aberto.
3. Selecione Projeto como o código-fonte WSDL. Clique em Procurar.
Procure o Web service CalculatorWS no projeto CalculatorWSApplication.
Depois de ter selecionado o Web service, clique em OK.

PÁGINA 11
4. Não selecione um nome de pacote. Deixe este campo vazio.

5. Deixe as outras definições como default e clique em Finalizar.

A janela Projetos exibirá o novo cliente de Web service, com um nó para
o método add que você criou:

PÁGINA 12
6. Clique duas vezes na classe principal para abri-la no Editor de Código-
Fonte. Arraste o nó adicionarabaixo do método main().

Agora você deverá ver o seguinte:

public static void main(String[] args) {
// TODO code application logic here
}
private static int add(int i, int j) {
org.me.calculator.CalculatorWS_Service service
= new org.me.calculator.CalculatorWS_Service();
org.me.calculator.CalculatorWS port =
service.getCalculatorWSPort();
return port.add(i, j);
}
Observação: como alternativa, em vez de arrastar o nó adicionar ,
você pode clicar com o botão direito do mouse no editor e, em seguida,
selecionar Inserir Código > Operação de Chamada a Web service.
7. No corpo do método main(), substitua o comentário TODO com o
código que inicializa os valores de ie j, chama add() e mostra o
resultado.
8. public static void main(String[] args) {
int i = 3;
int j = 4;
int result = add(i, j);
System.out.println("Result = " + result);
}
9. Circunde o código do método main() com um bloco try/catch que
imprime uma exceção.
10. public static void main(String[] args) {
try {
int i = 3;
int j = 4;
int result = add(i, j);
System.out.println("Result = " + result);
} catch (Exception ex) {
System.out.println("Exception: " + ex);
}
}

PÁGINA 13
 11. Clique com o botão direito do mouse no nó do projeto e selecione
Executar.
A janela de Saída agora mostra a soma:
compile:
run:
Result = 7
BUILD SUCCESSFUL (total time: 1 second)
Cliente 2: Servlet na Aplicação Web
Nesta seção, você cria uma nova aplicação Web e, depois disso, cria um servlet.
Em seguida, usa o servlet para consumir o Web service que criou no início deste
tutorial.
1. Selecione Arquivo > Novo Projeto (Ctrl-Shift-N no Linux e no Windows,
⌘-Shift-N no MacOS). Na categoria Java Web, selecione Aplicação Web.
Nomeie o projeto CalculatorWSServletClient. Clique em
Próximo e, em seguida, em Finalizar.
2. Clique com o botão direito do mouse no
nó CalculatorWSServletClient e selecione Novo > Cliente de
Web Service.
O assistente de Novo Cliente de Web Service será aberto.
3. Selecione Projeto como origem WSDL e clique em Procurar para abrir a
caixa de diálogo Procurar Web Services.
4. Selecione o web service CalculatorWS no projeto
CalculatorWSApplication. Clique em OK para fechar a caixa de diálogo
Procurar Web Services.

5. Confirme se o nome do pacote está vazio no assistente de Novo Cliente

de Web Service e deixe as outras definições com o valor padrão. Clique
em Finalizar.
O nó Referências de Web Service na janela Projetos exibe a estrutura do
cliente recém-criado, que inclui a operação add que você criou
anteriormente neste tutorial.

PÁGINA 14
6. Clique com o botão direito do mouse no nó do
projeto CalculatorWSServletClient e selecione Novo > Servlet.
Chame o servlet de ClientServlet e coloque-o em um pacote
chamado org.me.calculator.client. Clique em Finalizar.
7. Para tornar o servlet o ponto de entrada da aplicação, clique com o botão
direito do mouse no nó do projeto CalculatorWSServletClient e selecione
Propriedades. Abra as propriedades de Executar e
digite /ClientServlet no campo URL Relativo. Clique em OK.
8. Se houver ícones de erro em ClientServlet.java, clique com o
botão direito do mouse no nó do projeto e selecione Limpar e Construir.
9. No método processRequest(), adicione algumas linhas vazias
depois desta linha:
out.println("<h1>Servlet ClientServlet at " +
request.getContextPath () + "</h1>");
10. No Editor de Código-Fonte, arraste a operação adicionar em qualquer
lugar do corpo da classe ClientServlet. O método add() aparecerá
ao final do código da classe.
Observação: como alternativa, em vez de arrastar o nó adicionar ,
você pode clicar com o botão direito do mouse no editor e, em seguida,
selecionar Inserir Código > Operação de Chamada a Web service.
private int add(int i, int j) {
org.me.calculator.CalculatorWS port =
service.getCalculatorWSPort();
return port.add(i, j);
}
11. Adicione o código que inicializa os valores de i e j, chama add() e
imprime o resultado. O código adicionado está em negrito:
12. protected void processRequest(HttpServletRequest
request, HttpServletResponse response)
13. throws ServletException, IOException {
14.
response.setContentType("text/html;charset=UTF-
8");
15. PrintWriter out = response.getWriter();
16. try {
17. out.println("<html>");
18. out.println("<head>");
19. out.println("<title>Servlet
ClientServlet</title>");
20. out.println("</head>");
21. out.println("<body>");
22. out.println("<h1>Servlet ClientServlet at
" + request.getContextPath () + "</h1>");
23.

PÁGINA 15
24. int i = 3;
int j = 4;
int result = add(i, j);
out.println("Result = " + result);
25.
26. out.println("</body>");
27. out.println("</html>");
28.
} finally {
out.close();
}
}
29. Circunde o código adicionado com um bloco try/catch que imprime uma
exceção.
30. protected void processRequest(HttpServletRequest
request, HttpServletResponse response)
31. throws ServletException, IOException {
32.
response.setContentType("text/html;charset=UTF-
8");
33. PrintWriter out = response.getWriter();
34. try {
35. out.println("<html>");
36. out.println("<head>");
37. out.println("<title>Servlet
ClientServlet</title>");
38. out.println("</head>");
39. out.println("<body>");
40. out.println("<h1>Servlet ClientServlet at
" + request.getContextPath () + "</h1>");
41. try {
42. int i = 3;
int j = 4;
int result = add(i, j);
out.println("Result = " + result);
43. } catch (Exception ex) {
44. out.println("Exception: " + ex);
45. }
46. out.println("</body>");
47. out.println("</html>");
48.
} finally {
out.close();
}
}
49. Clique com o botão direito do mouse no nó do projeto e selecione
Executar.

PÁGINA 16
 O servidor será iniciado, a aplicação será construída e implantada e o
browser será aberto, exibindo o resultado do cálculo, como mostrado
abaixo:

Cliente 3: Página JSP na Aplicação Web

Nesta seção, você cria uma nova aplicação Web e, em seguida, consome o Web
service na página JSP default que o assistente Aplicação Web cria.
Observação: se você quiser executar um cliente de aplicação Web JSP em
Oracle WebLogic, consulte Executando uma Aplicação Java Server Faces 2.0
em WebLogic.
1. Selecione Arquivo > Novo Projeto (Ctrl-Shift-N no Linux e no Windows,
⌘-Shift-N no MacOS). Na categoria Java Web, selecione Aplicação Web.
Nomeie o projeto CalculatorWSJSPClient. Clique em Próximo e,
em seguida, em Finalizar.
2. Expanda o nó Páginas Web sob o nó do projeto e exclua index.html.
3. Clique com o botão direito do mouse no nó Páginas Web e escolha
Novo > JSP no menu pop-up.
Se JSP não estiver disponível no menu pop-up, escolha Novo > Outro e
selecione JSP na categoria Web do assistente de Novo Arquivo.
4. Digite index como nome do arquivo JSP no assistente de Novo Arquivo.
Clique em Finalizar.
5. Clique com o botão direito do mouse no
nó CalculatorWSJSPClient e selecione Novo > Cliente de Web
service.
6. Selecione Projeto como o código-fonte WSDL. Clique em Procurar.
Procure o Web service CalculatorWS no projeto CalculatorWSApplication.

PÁGINA 17
 Depois de ter selecionado o Web service, clique em OK.

7. Não selecione um nome de pacote. Deixe este campo vazio.

8. Deixe as outras definições como default e clique em Finalizar.
A janela Projetos exibe o novo cliente de web service, como mostrado
abaixo:

9. No nó Referências de Web Services, expanda o nó que representa o Web

service. A operação adicionar, que você chamará do cliente, agora
está exposta.
10. Arraste a operação adicionar para a página index.jsp do cliente e
solte-a abaixo das tags H1. O código para chamar a operação de serviço
agora é gerado na página index.jsp, como você pode ver aqui:
11. <%
12. try {
13. org.me.calculator.CalculatorWSService service
= new org.me.calculator.CalculatorWSService();

PÁGINA 18
 14. org.me.calculator.CalculatorWS port =
service.getCalculatorWSPort();
15. // TODO initialize WS operation arguments
here
16. int i = 0;
17. int j = 0;
18. // TODO process result here
19. int result = port.add(i, j);
20. out.println("Result = "+result);
21. } catch (Exception ex) {
22. // TODO handle custom exceptions here
23. }
%>
Altere o valor de i e j de 0 por outros inteiros, como 3 e 4. Substitua a
linha TODO comentada no bloco catch
por out.println("exception" + ex);.
24. Clique com o botão direito do mouse no nó do projeto e selecione
Executar.
O servidor será iniciado, caso já não esteja em execução. A aplicação
será construída e implantada e o browser será aberto, exibindo o
resultado do cálculo:

Enviar Feedback neste Tutorial

Consulte Também
Para obter mais informações sobre o uso do NetBeans IDE para desenvolver
aplicações Java EE, consulte os seguintes recursos:
 Desenvolvendo Clientes de Web Service JAX-WS
 Introdução ao RESTful Web Services
 Interoperabilidade Avançada de Web Service
 Trilha do Aprendizado de Web services
Para enviar comentários e sugestões, obter suporte e se manter informado sobre
os mais recentes desenvolvimentos das funcionalidades de desenvolvimento

PÁGINA 19
Java EE do NetBeans IDE, inscreva-se na lista de
notícias nbj2ee@netbeans.org.

PÁGINA 20