Desenvolvimento de clientes de serviço da Web JAX-WS
Neste tutorial, você utiliza os recursos de serviço Web fornecidos pelo NetBeans IDE para analisar um serviço Web de verificação ortográfica e depois cria um cliente Web que interaja com tal serviço. O cliente utiliza uma classe de servlet e uma página JSP. O usuário passa as informações da página JSP para o servlet.
Esta será a aparência do cliente, com todos os dados recebidos do serviço Web:
Ao final deste tutorial, você descobrirá que sua única contribuição à aplicação consiste em fornecer o texto a ser verificado, chamar uma operação no serviço Web e renderizar o resultado. O IDE gera todo o código necessário para entrar em contato com o serviço Web e enviar o texto. O serviço Web de verificador ortográfico cuida do resto, identifica as palavras escritas incorretamente e fornece uma lista das alternativas sugeridas.
O serviço Web de corretor ortográfico usado neste tutorial é fornecido pela CDYNE Corporation. A CDYNE desenvolve, comercializa e oferece suporte a um conjunto abrangente de serviços Web para análise de dados, qualidade de dados e aprimoramento de dados e integração de inteligência comercial. O serviço Web de verificador ortográfico é um dos serviços Web fornecidos pela CDYNE. Observe que a capacidade de uma aplicação baseada em um ou mais serviços Web depende da disponibilidade e confiabilidade dos serviços Web. Entretanto, as perguntas frequentes da CDYNE apontam que ela possui como "objetivo a disponibilidade total" e, no caso de um "desastre natural, ato terrorista ou outra catástrofe, o tráfego do serviço Web será transferido para o centro de dados secundário". A NetBeans agradece à CDYNE por permitir que este tutorial fosse escrito e por oferecer suporte ao seu desenvolvimento.
Consumindo o serviço Web de verificador ortográfico
Para usar um serviço Web através da rede, que é denominado "consumo" de um serviço Web, é preciso criar um cliente de serviço Web. Para a criação de clientes de serviço Web, o NetBeans IDE fornece um recurso de criação de cliente, que é o assistente para Cliente de serviço Web que gera o código para pesquisar um serviço Web. Ele também fornece recursos para desenvolver o cliente de serviço Web criado, que é uma área de trabalho que consiste em nós na janela Projetos. Esses recursos são parte da instalação padrão do NetBeans IDE, eles estão disponíveis para uso imediato e não são necessários plug-ins.
Criando o cliente
Nesta seção, você usa um assistente para gerar objetos Java a partir do arquivo WSDL do serviço Web.
Escolha Arquivo > Novo projeto (Ctrl-Shift-N). Em Categorias, escolha Java Web. Em Projetos , escolha Aplicação Web. Clique em Próximo. Nomeie o projeto como SpellCheckService e certifique-se de especificar um servidor apropriado como o servidor de destino. (Consulte a seção "Primeiros passos" para ver os detalhes). Aceite as outras configurações padrão e clique em Terminar.
Na janela Projetos, clique com o botão direito do mouse no nó do módulo de projeto e selecione Novo > Outro. No assistente para Novo arquivo, escolha Serviços Web > Cliente do serviço Web. No assistente do Cliente de serviço Web, especifique a URL para o serviço Web:
Se você estiver protegido por firewall, talvez tenha que especificar um servidor proxy, do contrário, o arquivo WSDL não poderá ser baixado. Para especificar o servidor proxy, clique em Configurações do proxy no assistente do Cliente de serviço Web e defina a máquina do proxy e o número da porta.
Deixe o nome do pacote em branco. Por padrão, o nome do pacote de classe do cliente é baseado no WSDL. Nesse caso, é com.cdyne.ws.
Selecione JAX versão JAX-WS (alguns serviços mais antigos requerem clientes JAX-RPC). Clique em Terminar.
Na janela Projetos, no nó Referências de serviço Web, você deverá ver o seguinte:
A janela Projetos mostra que um serviço Web chamado 'check' disponibilizou uma quantidade de operações 'CheckTextBody' e 'CheckTextBodyV2' para o aplicativo. Estas operações verificam se há erros de ortografia na string e retornam os dados para serem processados pelo cliente. A versão V2 do serviço não requer autenticação. A operação checkSoap.CheckTextBodyV2 será utilizada durante todo o tutorial.
No nó Códigos-fonte gerados , você verá os stubs cliente que foram gerados pelo assistente Serviço Web JAX-WS.
Expanda o nó WEB-INF e o subnó wsdl. Você encontra uma cópia local do arquivo WSDL, denominado check.asmx.wsdl.
O URL do WSDL que você usou para criar o cliente é mapeado para a cópia local do WSDL no jax-ws-catalog.xml. O mapeamento para a cópia local tem diversas vantagens. A cópia remota do WSDL não tem que estar disponível para que o cliente seja executado. O cliente é mais rápido porque não precisa analisar um arquivo WSDL remoto. Por último, a portabilidade é mais fácil. Para obter mais detalhes, consulte o artigo DZone Melhorias na portabilidade e no desempenho dos clientes JAX-WS criados com o NetBeans IDE 6.7.
Desenvolvendo o cliente
Há muitas maneiras de implementar um cliente de serviço Web. O arquivo WSDL do serviço Web restringe o tipo de informações que você pode enviar para o serviço Web e restringe o tipo de informações que você recebe de volta. Entretanto, o arquivo WSDL não faz restrições sobre como você passa as informações necessárias nem sobre o que consiste a interface do usuário. A implementação do cliente que você construirá a seguir consiste em uma página JSP que permite que o usuário insira o texto a ser verificado e um servlet que passa o texto para o serviço Web e depois produz um relatório contendo o resultado.
Codificando a página JSP
Nossa página JSP consiste de uma área de texto, onde o usuário inserirá um texto e um botão para enviar o texto para o serviço Web.
Na janela Projetos, expanda o nó Páginas Web do projeto SpellCheckerService e clique duas vezes em index.jsp para que ele seja aberto no Editor de código-fonte.
Copie o seguinte código e cole-o sobre as marcas <body> no index.jsp:
<body>
<form name="Test" method="post" action="SpellCheckServlet">
<p>Enter the text you want to check:</p>
<p>
<p><textarea rows="7" name="TextArea1" cols="40" ID="Textarea1"></textarea></p>
<p>
<input type="submit" value="Spell Check" name="spellcheckbutton">
</form>
</body>
O código acima listado especifica que, ao se clicar no botão Enviar, o conteúdo de textarea é postado em um servlet chamado SpellCheckServlet.
Criando e codificando o servlet
Nesta seção, você cria um servlet que irá interagir com o serviço Web. Entretanto, o código que realiza a interação será fornecido pelo IDE. Como resultado, você só precisa lidar com a lógica comercial, ou seja, a preparação do texto a ser enviado e o processamento do resultado.
Clique com o botão direito do mouse no nó do projeto SpellCheckService na janela Projetos, escolha Novo > Outro e escolha Web > Servlet. Clique em Próximo. O assistente para Novo servlet é aberto.
Nomeie o servlet como SpellCheckServlet e digite clientservlet na lista suspensa Pacote.
Clique em Próximo. O painel Configurar deployment do servlet é aberto. Observe que o mapeamento de URL deste servlet é /SpellCheckServlet. Aceite os padrões e clique em Terminar. O servlet se abrirá no Editor de código-fonte.
Coloque o cursor dentro do Editor de código-fonte, dentro do método processRequest e adicione algumas linhas novas logo acima do método.
Clique com o botão direito do mouse no espaço criado na etapa anterior e escolha Inserir código > Chamar operação de serviço Web. Clique na operação checkSoap.CheckTextBodyV2 na caixa de diálogo "Selecionar operação a ser chamada", conforme mostrado abaixo:
Clique em OK.
Observação: você também pode arrastar e soltar o nó da operação diretamente da janela Projetos no editor, em vez de chamar a caixa de diálogo mostrada acima.
No final da classe SpellCheckServlet, é exibido um método privado para chamar o serviço SpellCheckerV2 e retornar um objeto com.cdyne.ws.DocumentSummary.
Somente este método é necessário para chamar a operação no serviço Web. Além disso, as linhas de código a seguir são declaradas na parte superior da classe:
Substitua o bloco try do método processRequest() pelo código a seguir. Os comentários alinhados no código explicam a finalidade de cada linha.
try {
//Get the TextArea from the JSP page String TextArea1 = request.getParameter("TextArea1"); //Initialize WS operation arguments
java.lang.String bodyText = TextArea1;
//Process result
com.cdyne.ws.DocumentSummary doc = checkTextBodyV2(bodyText);
String allcontent = doc.getBody();
//From the retrieved document summary,
//identify the number of wrongly spelled words:
int no_of_mistakes = doc.getMisspelledWordCount();
//From the retrieved document summary,
//identify the array of wrongly spelled words:
List allwrongwords = doc.getMisspelledWord();
out.println("<html>");
out.println("<head>");
//Display the report's name as a title in the browser's titlebar:
out.println("<title>Spell Checker Report</title>");
out.println("</head>");
out.println("<body>");
//Display the report's name as a header within the body of the report:
out.println("<h2><font color='red'>Spell Checker Report</font></h2>");
//Display all the content (correct as well as incorrectly spelled) between quotation marks:
out.println("<hr><b>Your text:</b> \"" + allcontent + "\"" + "<p>");
//For every array of wrong words (one array per wrong word),
//identify the wrong word, the number of suggestions, and
//the array of suggestions. Then display the wrong word and the number of suggestions and
//then, for the array of suggestions belonging to the current wrong word, display each
//suggestion:
for (int i = 0; i < allwrongwords.size(); i++) {
String onewrongword = ((Words) allwrongwords.get(i)).getWord();
int onewordsuggestioncount = ((Words) allwrongwords.get(i)).getSuggestionCount();
List allsuggestions = ((Words) allwrongwords.get(i)).getSuggestions();
out.println("<hr><p><b>Wrong word:</b><font color='red'> " + onewrongword + "</font>");
out.println("<p><b>" + onewordsuggestioncount + " suggestions:</b><br>");
for (int k = 0; k < allsuggestions.size(); k++) {
String onesuggestion = (String) allsuggestions.get(k);
out.println(onesuggestion);
}
}
//Display a line after each array of wrong words:
out.println("<hr>");
//Summarize by providing the number of errors and display them:
out.println("<font color='red'><b>Summary:</b> " + no_of_mistakes + " mistakes (");
for (int i = 0; i < allwrongwords.size(); i++) {
String onewrongword = ((Words) allwrongwords.get(i)).getWord();
out.println(onewrongword);
}
out.println(").");
out.println("</font>");
out.println("</body>");
out.println("</html>");
} catch (Exception ex) {
out.println("exception" + ex);
} finally {
out.close();
}
Você verá diversas barras de erros e ícones de aviso indicando quais as classes que não foram encontradas. Para corrigir as importações depois de colar o código, pressione Ctrl-Shift-I em qualquer local, o que abre um menu de contexto, e selecione Corrigir importações. (Você tem uma opção de listar as classes para importar. Aceite o java.util.List padrão). Segue a lista das classes importadas:
Observação: Se forem exibidos avisos de que não foi possível encontrar as classes com.cdyne.*, não se assuste. Este problema é resolvido quando você constrói o projeto, conforme o IDE analisa os arquivos WSDL e encontra as classes.
Observe que não houve tratamento de erros no código acima listado. Consulte Aplicando o que você aprendeu para obter detalhes.
Implantando o cliente
O IDE utiliza um script de construção Ant para construir os módulos. O IDE gera o script de construção com base nas opções inseridas ao criar o projeto. Você pode ajustar estas opções na caixa de diálogo Propriedades do projeto do projeto (clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Propriedades).
Clique com o botão direito do mouse no nó do projeto e escolha Executar. Após um tempo, o aplicativo é implementado e exibe a página JSP codificada na seção anterior.
Insira um texto, parte dele escrito incorretamente:
Clique em Verificar ortografia e veja o resultado:
Clientes assíncronos de serviço Web
Por padrão, os clientes JAX-WS criados pelo NetBeans IDE são assíncronos. Os clientes assíncronos chamam uma solicitação em um serviço e, a seguir, interrompem seus processamentos enquanto aguardam a resposta. No entanto, em alguns casos, você quer que o cliente continue com outros processamentos em vez de aguardar a resposta. Em alguns casos, por exemplo, o serviço pode demorar muito tempo em processar a solicitação. Os clientes de serviço Web que continuam processando sem aguardar a resposta do serviço são chamados de "assíncronos".
Os clientes assíncronos iniciam uma solicitação de um serviço e, a seguir, retomam seu processamento sem aguardar uma resposta. O serviço manipula a solicitação do cliente e devolve uma resposta algum tempo mais tarde, em cujo momento o cliente recupera a resposta e continua com seu processamento.
Os clientes assíncronos consomem serviços Web através da abordagem "sondagem" ou "retorno de chamada". Na abordagem "sondagem", você chama um método de serviço Web e pede repetitivamente o resultado. A sondagem é uma operação de bloqueio porque bloqueia o segmento que está realizando a chamada, que é a razão pela qual você não quer usá-la em uma aplicação de GUI. Na abordagem "retorno de chamada", você passa por um manipulador de retorno de chamada durante a chamada do método de serviço Web. O método handleResponse() do manipulador é chamado quando o resultado estiver disponível. Esta abordagem é apropriada para aplicações de GUI porque não é necessário esperar a resposta. Por exemplo, você faz uma chamada a partir de um manipulador de eventos de GUI e retorna o controle imediatamente, mantendo a interface de usuário receptiva. A desvantagem da abordagem sondagem é que, mesmo que a resposta seja utilizada após ser obtida, você tem que averiguar para saber se ela foi obtida.
No NetBeans IDE, você adiciona suporte para clientes assíncronos a um aplicativo de serviço Web marcando um quadro na GUI de Editar atributos do serviço Web nas referências do serviço Web. Todos os outros aspectos do desenvolvimento de clientes são iguais aos dos clientes síncronos, exceto pela presença dos métodos de sondar o serviço Web ou passar pelo manipulador de retorno de chamada e aguardar o resultado.
O restante desta seção explica como criar uma interface gráfica Swing e incorporar nela um cliente assíncrono JAX-WS.
O cliente Swing pega o texto que você digitou, envia-o ao serviço e devolve o número de erros e uma lista de todas as palavras erradas. O cliente também mostra cada uma das palavras erradas e as sugestões para substituí-la, uma de cada vez.
Para criar o cliente Swing :
Crie um novo projeto de aplicativo Java. Chame-o de AsynchSpellCheckClient. NÃO crie uma classe Main para o projeto.
Na janela Projetos, clique com o botão direito do mouse no nó do projeto AsynchSpellCheckClient e selecione Novo > Formulário JFrame...
Chame o formulário de MainForm e coloque-o no pacote org.me.forms.
Após a criar o JFrame, abra as propriedades do projeto. Na categoria Executar, defina MainForm como classe principal.
No Editor, abra a visualização Desenho de MainForm.java. Da Paleta, arraste e solte três painéis de rolagem no MainForm. Posicione e ajuste a tamanho dos painéis de rolagem. Eles conterão os campos de texto dos textos digitados para verificação, todas as palavras erradas e as sugestões para uma palavra errada.
Arraste e solte cinco campos de texto no MainForm. Arraste três deles para dentro dos painéis de rolagem. Modifique-os da seguinte forma:
campos de texto
Nome da variável
No painel de rolagem?
Editável?
tfYourText
S
S
tfNumberMistakes
N
N
tfWrongWords
S
N
tfWrongWord1
N
N
tfSuggestions1
S
N
Arraste e solte uma barra de progresso no MainFrame. Chame a variável de pbProgress.
Arraste e solte dois botões no MainFrame. Chame o primeiro botão de btCheck e altere seu texto para Verificar texto ou Verificar ortografia. Chame o segundo botão de btNextWrongWord, altere seu texto para Próxima palavra errada e desative-o.
Arraste e solte alguns rótulos no MainFrame para dar um título ao aplicativo e para descrever os campos de texto.
Arrume a aparência do JFrame de acordo com a sua preferência e salve-o. Depois, você adiciona a funcionalidade de cliente de serviço Web.
Ativando clientes assíncronos
Adicione as referências do serviço Web, conforme descrito em Criando o cliente. A seguir, edite os atributos do serviço Web para ativar os clientes assíncronos.
Na janela Projetos, clique com o botão direito do mouse no nó AsynchSpellCheckClient do projeto e selecione Novo > Outro. No assistente para Novo arquivo, escolha Serviços Web > Cliente do serviço Web. No assistente do Cliente de serviço Web, especifique a URL para o serviço Web:
Expanda o nó Referências de serviços Web e clique com o botão direito no serviço check. O menu de contexto se abre.
No menu de contexto, selecione Editar atributos do serviço Web. A caixa de diálogo Atributos do serviço Web se abre.
Selecione a aba Personalização de WSDL.
Expanda o nó Operações do tipo de porta. Expanda o primeiro nó CheckTextBodyV2 e selecione Habilitar cliente assíncrono.
Clique em OK. A caixa de diálogo se fecha e é exibido um aviso de que a alteração dos atributos do serviço Web atualizarão o nó do cliente.
Clique em OK. O aviso se fecha e o nó do cliente é atualizado. Se expandir o nó check em Referências de serviço Web, verá que agora possui as versões Sondagem e Retorno de chamada da operação CheckTextBody.
Os clientes assíncronos de serviço Web do serviço SpellCheck estão agora habilitados para seu aplicativo.
Adicionando o código de cliente assíncrono
Agora que possui operações assíncronas de serviço Web, adicione uma operação assíncrona ao MainFrame.java.
Para adicionar o código de cliente assíncrono:
No MainFrame, passe para a visualização Código-fonte e adicione o seguinte método antes da última chave de fechamento.
public void callAsyncCallback(String text){
}
Na janela Projetos, expanda o nó Referências de serviço Web do AsynchSpellCheckService e localize a operação checkSoap.CheckTextBodyV2 [Asynch Callback].
Arraste a operação CheckTextBodyV2 [Asynch Callback] para o corpo do método callAsynchCallback vazio. O IDE gera o seguinte bloco try. Compare este código gerado ao código gerado para o cliente assíncrono.
try { // Call Web Service Operation(async. callback)
com.cdyne.ws.Check service = new com.cdyne.ws.Check();
com.cdyne.ws.CheckSoap port = service.getCheckSoap();
// TODO initialize WS operation arguments here
java.lang.String bodyText = "";
javax.xml.ws.AsyncHandler<com.cdyne.ws.CheckTextBodyV2Response> asyncHandler =
new javax.xml.ws.AsyncHandler<com.cdyne.ws.CheckTextBodyV2Response>() {
public void handleResponse(javax.xml.ws.Response<com.cdyne.ws.CheckTextBodyV2Response> response) {
try {
// TODO process asynchronous response here
System.out.println("Result = "+ response.get());
} catch(Exception ex) {
// TODO handle exception
}
}
};
java.util.concurrent.Future<? extends java.lang.Object> result = port.checkTextBodyV2Async(bodyText, asyncHandler);
while(!result.isDone()) {
// do something
Thread.sleep(100);
}
} catch (Exception ex) {
// TODO handle custom exceptions here
}
Neste código, junto com a chamada do serviço Web, você observa que a resposta do serviço SpellCheck é manipulada através de um objeto AsynchHandler. Enquanto isso, um objeto Future verifica se um resultado foi devolvido e inativa a thread até que o resultado seja concluído.
Volte para a visualização Desenho. Clique duas vezes no botão Verificar ortografia. O IDE adiciona automaticamente um ActionListener ao botão e passa para a visualização Código-fonte, com o cursor no método btCheckActionPerformed vazio.
Adicione o seguinte código ao corpo do método btCheckActionPerformed. Este código toma o texto que você digitou no campo tfYourText, exibe a mensagem "aguardando servidor" na barra de progresso, desabilita o botão btCheck e chama o método de retorno de chamada assíncrono.
private void btCheckActionPerformed(java.awt.event.ActionEvent evt) {
String text = tfYourText.getText();
pbProgress.setIndeterminate(true);
pbProgress.setString("waiting for server");
btCheck.setEnabled(false);
callAsynchCallback(text);
}
No início da classe MainFrame, instancie um campo ActionListener privado denominado nextWord. Este ActionListener é para que o botão Próxima palavra errada passe para a seguinte palavra errada da lista de palavras erradas e exiba a palavra e as sugestões de correção. Você cria o campo privado aqui, assim você pode cancelar o registro de ActionListener se já tiver sido definido. Do contrário, sempre que você verificasse um novo texto, teria que adicionar um Listener e o resultado seria vários Listeners chamando actionPerformed() várias vezes. O aplicativo não se comportaria corretamente.
public class MainForm extends javax.swing.JFrame {
private ActionListener nextWord;
...
Substitua todo o método callAsynchCallback pelo seguinte código. Observe que o bloco try mais externo foi removido. Isso é desnecessário porque blocos try mais específicos são adicionados dentro do método. Outras alterações no código são esclarecidas nos comentários do código.
public void callAsynchCallback(String text) {
com.cdyne.ws.Check service = new com.cdyne.ws.Check();
com.cdyne.ws.CheckSoap port = service.getCheckSoap();
// initialize WS operation arguments here
java.lang.String bodyText = text;
javax.xml.ws.AsyncHandler<com.cdyne.ws.CheckTextBodyV2Response> asyncHandler = new javax.xml.ws.AsyncHandler<com.cdyne.ws.CheckTextBodyV2Response>() {
public void handleResponse(final javax.xml.ws.Response<com.cdyne.ws.CheckTextBodyV2Response> response) {
SwingUtilities.invokeLater(new Runnable() {
public void run() {
try {
// Create a DocumentSummary object containing the response.
// Note that getDocumentSummary() is called from the Response object
// unlike the synchronous client, where it is called directly from
// com.cdyne.ws.CheckTextBody
com.cdyne.ws.DocumentSummary doc = response.get().getDocumentSummary();
//From the retrieved DocumentSummary,
//identify and display the number of wrongly spelled words:
final int no_of_mistakes = doc.getMisspelledWordCount();
String number_of_mistakes = Integer.toString(no_of_mistakes);
tfNumberMistakes.setText(number_of_mistakes);
// Check to see if there are any mistakes
if (no_of_mistakes > 0) {
//From the retrieved document summary,
//identify the array of wrongly spelled words, if any:
final List<com.cdyne.ws.Words> allwrongwords = doc.getMisspelledWord();
//Get the first wrong word
String firstwrongword = allwrongwords.get(0).getWord();
//Build a string of all wrong words separated by commas, then display this in tfWrongWords
StringBuilder wrongwordsbuilder = new StringBuilder(firstwrongword);
for (int i = 1; i < allwrongwords.size(); i++) {
String onewrongword = allwrongwords.get(i).getWord();
wrongwordsbuilder.append(", ");
wrongwordsbuilder.append(onewrongword);
}
String wrongwords = wrongwordsbuilder.toString();
tfWrongWords.setText(wrongwords);
//Display the first wrong word
tfWrongWord1.setText(firstwrongword);
//See how many suggestions there are for the wrong word
int onewordsuggestioncount = allwrongwords.get(0).getSuggestionCount();
//Check to see if there are any suggestions.
if (onewordsuggestioncount > 0) {
//Make a list of all suggestions for correcting the first wrong word, and build them into a String.
//Display the string of concactenated suggestions in the tfSuggestions1 text field
List<String> allsuggestions = ((com.cdyne.ws.Words) allwrongwords.get(0)).getSuggestions();
String firstsuggestion = allsuggestions.get(0);
StringBuilder suggestionbuilder = new StringBuilder(firstsuggestion);
for (int i = 1; i < onewordsuggestioncount; i++) {
String onesuggestion = allsuggestions.get(i);
suggestionbuilder.append(", ");
suggestionbuilder.append(onesuggestion);
}
String onewordsuggestions = suggestionbuilder.toString();
tfSuggestions1.setText(onewordsuggestions);
} else {
// No suggestions for this mistake
tfSuggestions1.setText("No suggestions");
}
btNextWrongWord.setEnabled(true);
// See if the ActionListener for getting the next wrong word and suggestions
// has already been defined. Unregister it if it has, so only one action listener
// will be registered at one time.
if (nextWord != null) {
btNextWrongWord.removeActionListener(nextWord);
}
// Define the ActionListener (already instantiated as a private field)
nextWord = new ActionListener() {
//Initialize a variable to track the index of the allwrongwords list
int wordnumber = 1;
public void actionPerformed(ActionEvent e) {
if (wordnumber < no_of_mistakes) {
// get wrong word in index position wordnumber in allwrongwords
String onewrongword = allwrongwords.get(wordnumber).getWord();
//next part is same as code for first wrong word
tfWrongWord1.setText(onewrongword);
int onewordsuggestioncount = allwrongwords.get(wordnumber).getSuggestionCount();
if (onewordsuggestioncount > 0) {
List<String> allsuggestions = allwrongwords.get(wordnumber).getSuggestions();
String firstsuggestion = allsuggestions.get(0);
StringBuilder suggestionbuilder = new StringBuilder(firstsuggestion);
for (int j = 1; j < onewordsuggestioncount; j++) {
String onesuggestion = allsuggestions.get(j);
suggestionbuilder.append(", ");
suggestionbuilder.append(onesuggestion);
}
String onewordsuggestions = suggestionbuilder.toString();
tfSuggestions1.setText(onewordsuggestions);
} else {
tfSuggestions1.setText("No suggestions");
}
// increase i by 1
wordnumber++;
} else {
// No more wrong words! Disable next word button
// Enable Check button
btNextWrongWord.setEnabled(false);
btCheck.setEnabled(true);
}
}
};
// Register the ActionListener
btNextWrongWord.addActionListener(nextWord);
} else {
// The text has no mistakes
// Enable Check button
tfWrongWords.setText("No wrong words");
tfSuggestions1.setText("No suggestions");
tfWrongWord1.setText("--");
btCheck.setEnabled(true);
}
} catch (Exception ex) {
ex.printStackTrace();
}
// Clear the progress bar
pbProgress.setIndeterminate(false);
pbProgress.setString("");
}
});
}
};
java.util.concurrent.Future result = port.checkTextBodyV2Async(bodyText, asyncHandler);
while (!result.isDone()) {
try {
//Display a message that the application is waiting for a response from the server
tfWrongWords.setText("Waiting...");
Thread.sleep(100);
} catch (InterruptedException ex) {
Logger.getLogger(MainForm.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
Pressione Ctrl-Shift-I e corrija as importações. Isso adiciona as seguintes instruções de importação:
Agora, você pode construir e executar o aplicativo! Infelizmente, você provavelmente não vê o que acontece quando há muita demora na resposta do servidor porque o serviço é bastante rápido.
Praticando o que você aprendeu
Agora que você concluiu o seu primeiro cliente de serviço Web no IDE, é hora de aprimorar suas habilidades e melhorar a aplicação para tirar o melhor proveito dela. Veja a seguir duas tarefas sugeridas para começar.
Adicione código de tratamento de erro ao servlet.
Reescreva o cliente para que o usuário possa interagir com os dados retornados do serviço Web.
Para enviar comentários e sugestões, obter suporte e se manter informado sobre os mais recentes desenvolvimentos dos recursos de desenvolvimento de Java EE do NetBeans IDE, inscreva-se na lista de correspondência .
