1. 创建新的 Java 应用程序项目。将其命名为?AsynchSpellCheckClient。不要为该项目创建?Main?类。
2. 在 "Projects"（项目）视图中，右键单击?AsynchSpellCheckClient?项目节点并选择 "New"（新建）> "JFrame Form..."（JFrame 窗体...）。
3. 将该窗体命名为?MainForm，然后将其放置在包?org.me.forms?中。
4. 创建 JFrame 后，打开项目属性。在 "Run"（运行）类别中，将?MainForm?设置为主类。?
   

   

5. 在编辑器中，打开?MainForm.java?的 "Design"（设计）视图。在组件面板中，将三个滚动窗格拖放至?MainForm?中。定位滚动窗格并调整其大小。这些窗格将包含要进行检查所键入的文本、所有错误词语以及对某个错误词语提出的建议的文本字段。
6. 将五个文本字段拖放至?MainForm?中。将其中的三个拖放至三个滚动窗格中。按如下方式对其进行修改：

   文本字段
   变量名称	在滚动窗格中？	可编辑？
   tfYourText	Y	Y
   tfNumberMistakes	N	N
   tfWrongWords	tfWrongWord1	tfSuggestions1	N

7. 将进度栏拖放至?MainForm?中。将该变量命名为?pbProgress。
8. 将两个按钮拖放至?MainForm?中。将第一个按钮命名为?btCheck，并将其文本更改为 "Check Text" 或 "Check Spelling"。将第二个按钮命名为?btNextWrongWord，将其文本更改为 "Next Wrong Word"，然后禁用该按钮。
9. 将一些标签拖放至?MainForm?中，为应用程序提供一个标题并描述文本字段。

将 JFrame 的外观按您喜欢的方式进行排列，然后进行保存。接下来将添加 Web 服务客户端功能。

启用异步客户端

如创建客户端中所述，添加 Web 服务引用。然后编辑 Web 服务属性以启用异步客户端。

AsynchSpellCheckClient?项目节点，然后选择 "New"（新建）> "Other"（其他）。在新建文件向导中，选择 "Web Services"（Web 服务）> "Web Service Client"（Web 服务客户端）。在“Web 服务客户端”向导中，指定 Web 服务的 URL：

http://wsf.cdyne.com/SpellChecker/check.asmx?wsdl。接受所有默认值，然后单击 "Finish"（完成）。这与创建客户端中所述步骤 2 以后的过程相同。

1. 展开 "Web Service References"（Web 服务引用）节点，然后右键单击?check?服务。上下文菜单打开。
   

   

2. 从上下文菜单中选择 "Edit Web Service Attributes"（编辑 Web 服务属性）。“Web 服务属性”对话框打开。
3. 选择 "WSDL Customization"（WSDL 定制”）签。
4. 展开 "Port Type Operations"（端口类型操作）节点。展开第一个?CheckTextBodyV2?节点并选择 "Enable Asynchronous Client"（启用异步客户端）。?
   

   

5. 单击 "OK"（确定）。该对话框关闭，并出现一条警告，指出更改 Web 服务属性将会刷新客户端节点。
   

   

6. 单击 "OK"（确定）。该警告信息关闭，并刷新客户端节点。如果展开 "Web Service References"（Web 服务引用）中的?check?节点，则会看到现在已具有?CheckTextBody?操作的 "Polling"（轮询）和 "Callback"（回调）版本。
   

   

现已为您的应用程序启用了 SpellCheck 服务的异步 Web 服务客户端。

添加异步客户端代码

现在，您已经有了异步 Web 服务操作，可将其中一个异步操作添加到?MainForm.java?中。

添加异步客户端代码：

1. 在?MainForm?中，切换到 "Source"（源）视图，然后将以下方法添加到最后一个右花括号的前面。?
   

   public void callAsyncCallback(String text){
                    
   }

2. 在 "Projects"（项目）窗口中，展开?AsynchSpellCheckClient?的 "Web Service References"（Web 服务引用）节点，并找到?checkSoap.CheckTextBodyV2 [Asynch Callback]?操作。
   
3. 将?CheckTextBodyV2 [Asynch Callback]?操作拖至空的?callAsyncCallback?方法主体中。IDE 会生成以下?try?块。将此生成的代码与为同步客户端生成的代码进行比较。

   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
   }

   在此代码与 Web 服务调用中，您会看到来自 SpellCheck 服务的响应是通过?AsynchHandler?对象进行处理的。同时，Future?对象会查看是否已返回了结果，然后使线程休眠直至完全返回了结果。

4. 切换回 "Design"（设计）视图。双击 "Check Spelling" 按钮。IDE 会自动将 "ActionListener" 添加到按钮中，然后切换到 "Source"（源）视图中，光标同时出现在空的btCheckActionPerformed?方法中。
5. 将以下代码添加至?btCheckActionPerformed?方法主体。此代码会获取您在?tfYourText?字段中键入的文本，使进度栏显示 "waiting for server" 消息，并禁用?btCheck?按钮，以及调用异步回调方法。

   private void btCheckActionPerformed(java.awt.event.ActionEvent evt) {                                        
       String text = tfYourText.getText();
       pbProgress.setIndeterminate(true);
       pbProgress.setString("waiting for server");
       btCheck.setEnabled(false);
       callAsyncCallback(text);
   }

6. 在?MainForm?类的开头，实例化名为?nextWord?的私有?ActionListener?字段。此?ActionListener?字段是为 Next Wrong Word 按钮提供的，使用该按钮可以前进到错误词语列表中的下一个错误词语，并显示该词语以及更正它的建议。您可以在此处创建私有字段，这样就可以在定义了?ActionListener?的情况下取消对其的注册。否则，每次检查新文本时，都将添加一个额外的监听程序并最终出现多个监听程序多次调用?actionPerformed()?的情况。这样，该应用程序将无法正常运行。

   public class MainForm extends javax.swing.JFrame {
       
       private ActionListener nextWord;
       ...

7. 将整个?callAsyncCallback?方法替换为以下代码。请注意，最外层的?try?块已删除。此代码块是多余的，因为已在方法内添加了更多特定的?try?块。并且在代码注释中介绍了对代码所做的其他更改。?
   

   public void callAsyncCallback(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);
           }
       }
   }

8. 按 Ctrl-Shift-I 组合键（在 Mac 上按 ?-Shift-I 组合键）并修复导入。这样会添加以下 import 语句：

   import java.awt.event.ActionEvent;
   import java.awt.event.ActionListener;
   import java.util.List;
   import java.util.logging.Level;
   import java.util.logging.Logger;
   import javax.swing.SwingUtilities;

现在，您可以构建并运行应用程序了！遗憾的是，您不可能在获取服务器响应的很长延迟时间里看到所发生的变化，因为服务的处理速度相当快。

应用所学知识

现在，您已在 IDE 中创建了第一个 Web 服务客户端，接下来该您大显身手，对应用程序进行全方位扩展了。下面建议了两项可着手执行的任务。

• 在 Servlet 中添加错误处理代码。
• 重写客户端，以使用户可与从 Web 服务返回的数据进行交互。