掌握 Ajax，第 3 部分: Ajax 中的高级请求和响应

亦凉 2021-12-17 05:34 207阅读 0赞

<table> 
 <tbody> 
  <tr> 
   <td> <p><em>全面理解 HTTP 的状态代码、就绪状态和 XMLHttpRequest 对象</em></p> <img height="6" alt="" src="http://www.ibm.com/i/c.gif" width="1"></td> 
   <td><img height="18" alt="developerWorks" src="http://www.ibm.com/developerworks/i/dw.gif" width="192"></td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10"></td> 
   <td> 
    <table> 
     <tbody> 
      <tr> 
       <td><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10"></td> 
       <td> 
        <table> 
         <tbody> 
          <tr> 
           <td>文档选项</td> 
          </tr> 
         </tbody> 
        </table> 
        <table> 
         <tbody> 
          <tr> 
           <td> 
            <table> 
             <tbody> 
              <tr> 
               <td><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="8"></td> 
               <td><img height="16" alt="将此页作为电子邮件发送" src="http://www.ibm.com/i/v14/icons/em.gif" width="16"></td> 
               <td> <p><a rel="nofollow"><strong>将此页作为电子邮件发送</strong></a></p> </td> 
              </tr> 
              <tr> 
               <td><img alt="" height="1" width="8"></td> 
               <td><img alt="" width="16" height="16"></td> 
               <td> <p><span>未显示需要 JavaScript 的文档选项</span></p> </td> 
              </tr> 
              <tr> 
               <td><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="8"></td> 
               <td><img height="16" alt="" src="http://www.ibm.com/i/v14/icons/fw_bold.gif" width="16"></td> 
               <td> <p><a href="http://www.ibm.com/developerworks/community/" rel="nofollow"><strong>讨论</strong></a></p> </td> 
              </tr> 
              <tr> 
               <td><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="8"></td> 
               <td><img height="16" alt="" src="http://www.ibm.com/i/v14/icons/dn.gif" width="16"></td> 
               <td> <p><a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#download" rel="nofollow"><strong>样例代码</strong></a></p> </td> 
              </tr> 
             </tbody> 
            </table></td> 
          </tr> 
         </tbody> 
        </table><br></td> 
      </tr> 
     </tbody> 
    </table><p>级别： 初级</p> <p><a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#author" rel="nofollow">Brett McLaughlin</a> (<a href="mailto:brett@newInstance.com?subject=Ajax%20%E4%B8%AD%E7%9A%84%E9%AB%98%E7%BA%A7%E8%AF%B7%E6%B1%82%E5%92%8C%E5%93%8D%E5%BA%94&amp;amp;cc=htc@us.ibm.com" rel="nofollow">mailto:brett@newInstance.com?subject=Ajax 中的高级请求和响应&amp;cc=htc@us.ibm.com</a>), 作家，编辑, O'Reilly Media Inc.<br></p> <p>2006 年 3 月 23 日</p> 
    <blockquote>
      对于很多 Web 开发人员来说，只需要生成简单的请求并接收简单的响应即可；但是对于希望掌握 Ajax 的开发人员来说，必须要全面理解 HTTP 状态代码、就绪状态和 XMLHttpRequest 对象。在本文中，Brett McLaughlin 将向您介绍各种状态代码，并展示浏览器如何对其进行处理，本文还给出了在 Ajax 中使用的比较少见的 HTTP 请求。 
    </blockquote> <p>在本系列的 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro2/" rel="nofollow">上篇文章</a> 中，我们将详细介绍 <code>XMLHttpRequest</code> 对象，它是 Ajax 应用程序的中心，负责处理服务器端应用程序和脚本的请求，并处理从服务器端组件返回的数据。由于所有的 Ajax 应用程序都要使用 <code>XMLHttpRequest</code> 对象，因此您可能会希望熟悉这个对象，从而能够让 Ajax 执行得更好。</p> <p>在本文中，我将在上一篇文章的基础上重点介绍这个请求对象的 3 个关键部分的内容：</p> 
    <ul> 
     <li>HTTP 就绪状态 </li> 
     <li>HTTP 状态代码 </li> 
     <li>可以生成的请求类型 </li> 
    </ul><p>这三部分内容都是在构造一个请求时所要考虑的因素；但是介绍这些主题的内容太少了。然而，如果您不仅仅是想了解 Ajax 编程的常识，而是希望了解更多内容，就需要熟悉就绪状态、状态代码和请求本身的内容。当应用程序出现问题时 —— 这种问题总是存在 —— 那么如果能够正确理解就绪状态、如何生成一个 HEAD 请求或者 400 的状态代码的确切含义，就可以在 5 分钟内调试出问题，而不是在各种挫折和困惑中度过 5 个小时。</p> 
    <table> 
     <tbody> 
      <tr> 
       <td><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10"></td> 
       <td> 
        <table> 
         <tbody> 
          <tr> 
           <td><a rel="nofollow"><strong>XMLHttpRequest 或 XMLHttp：换名玫瑰</strong></a><br><p>Microsoft™ 和 Internet Explorer 使用了一个名为 <code>XMLHttp</code> 的对象，而不是 <code>XMLHttpRequest</code> 对象，而 Mozilla、Opera、Safari 和 大部分非 Microsoft 浏览器都使用的是后者。为了简单性起见，我将这两个对象都简单地称为 <code>XMLHttpRequest</code>。这既符合我们在 Web 上看到的情况，又符合 Microsoft 在 Internet Explorer 7.0 中使用 <code>XMLHttpRequest</code> 作为请求对象的意图。（有关这个问题的更多内容，请参见 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro2/" rel="nofollow">第 2 部分</a>。）</p> </td> 
          </tr> 
         </tbody> 
        </table></td> 
      </tr> 
     </tbody> 
    </table><p>下面让我们首先来看一下 HTTP 就绪状态。</p> <p><a rel="nofollow"><span>深入了解 HTTP 就绪状态</span></a></p> <p>您应该还记得在上一篇文章中 <code>XMLHttpRequest</code> 对象有一个名为 <code>readyState</code> 的属性。这个属性确保服务器已经完成了一个请求，通常会使用一个回调函数从服务器中读出数据来更新 Web 表单或页面的内容。<a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing1" rel="nofollow">清单 1</a> 给出了一个简单的例子（这也是本系列的上一篇文章中的一个例子 —— 请参见 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#resources" rel="nofollow">参考资料</a>）。</p> <br><a rel="nofollow"><strong>清单 1. 在回调函数中处理服务器的响应</strong></a><br> 
    <table> 
     <tbody> 
      <tr> 
       <td> <pre> function updatePage() {
                        <span>if (request.readyState == 4) {
            </span>
                        if (request.status == 200) {
                        var response = request.responseText.split("|");
                        document.getElementById("order").value = response[0];
                        document.getElementById("address").innerHTML =
                        response[1].replace(/\n/g, "&lt;br /&gt;");
                        } else
                        alert("status is " + request.status);
                        }
                        }
                        </pre> </td> 
      </tr> 
     </tbody> 
    </table><br><p>这显然是就绪状态最常见（也是最简单）的用法。正如您从数字 "4" 中可以看出的一样，还有其他几个就绪状态（您在上一篇文章中也看到过这个清单 —— 请参见 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#resources" rel="nofollow">参考资料</a>）：</p> 
    <ul> 
     <li><strong>0</strong>：请求未初始化（还没有调用 <code>open()</code>）。 </li> 
     <li><strong>1</strong>：请求已经建立，但是还没有发送（还没有调用 <code>send()</code>）。 </li> 
     <li><strong>2</strong>：请求已发送，正在处理中（通常现在可以从响应中获取内容头）。 </li> 
     <li><strong>3</strong>：请求在处理中；通常响应中已有部分数据可用了，但是服务器还没有完成响应的生成。 </li> 
     <li><strong>4</strong>：响应已完成；您可以获取并使用服务器的响应了。 </li> 
    </ul><p>如果您希望不仅仅是了解 Ajax 编程的基本知识，那么就不但需要知道这些状态，了解这些状态是何时出现的，以及如何来使用这些状态。首先，您需要学习在每种就绪状态下可能碰到的是哪种请求状态。不幸的是，这一点并不直观，而且会涉及几种特殊的情况。</p> <p><a rel="nofollow"><span>隐秘就绪状态</span></a></p> <p>第一种就绪状态的特点是 <code>readyState</code> 属性为 0（<code>readyState == 0</code>），表示未初始化状态。一旦对请求对象调用 <code>open()</code> 之后，这个属性就被设置为 1。由于您通常都是在一对请求进行初始化之后就立即调用 <code>open()</code>，因此很少会看到 <code>readyState == 0</code> 的状态。另外，未初始化的就绪状态在实际的应用程序中是没有真正的用处的。</p> <p>不过为了满足我们的兴趣，请参见 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing2" rel="nofollow">清单 2</a> 的内容，其中显示了如何在 readyState 被设置为 0 时来获取这种就绪状态。</p> <br><a rel="nofollow"><strong>清单 2. 获取 0 就绪状态</strong></a><br> 
    <table> 
     <tbody> 
      <tr> 
       <td> <pre>   function getSalesData() {
                        // Create a request object
                        createRequest();
                        <span>alert("Ready state is: " + request.readyState);</span>
                        // Setup (initialize) the request
                        var url = "/boards/servlet/UpdateBoardSales";
                        request.open("GET", url, true);
                        request.onreadystatechange = updatePage;
                        request.send(null);
                        }
                        </pre> </td> 
      </tr> 
     </tbody> 
    </table><br><p>在这个简单的例子中，<code>getSalesData()</code> 是 Web 页面调用来启动请求（例如点击一个按钮时）所使用的函数。注意您必须在调用 <code>open()</code> <em>之前</em> 来查看就绪状态。<a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#fig1" rel="nofollow">图 1</a> 给出了运行这个应用程序的结果。</p> <br><a rel="nofollow"><strong>图 1. 就绪状态 0</strong></a><br><img height="329" alt="就绪状态 0" src="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/ready-state_0.jpg" width="500"><br> 
    <table> 
     <tbody> 
      <tr> 
       <td><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10"></td> 
       <td> 
        <table> 
         <tbody> 
          <tr> 
           <td><a rel="nofollow"><strong>当 0 等于 4 时</strong></a><br><p>在多个 JavaScript 函数都使用相同的请求对象时，您需要检查就绪状态 0 来确保这个请求对象没有正在使用，这种机制会产生问题。由于 <code>readyState == 4</code> 表示一个已完成的请求，因此您经常会发现那些目前没在使用的处于就绪状态的请求对象仍然被设置成了 4 —— 这是因为从服务器返回来的数据已经使用过了，但是从它们被设置为就绪状态之后就没有进行任何变化。有一个函数 <code>abort()</code> 会重新设置请求对象，但是这个函数却不是真正为了这个目的而使用的。如果您 <em>必须</em> 使用多个函数，最好是为每个函数都创建并使用一个函数，而不是在多个函数之间共享相同的对象。</p> </td> 
          </tr> 
         </tbody> 
        </table></td> 
      </tr> 
     </tbody> 
    </table><p>显然，这并不能为您带来多少好处；需要确保 <em>尚未</em> 调用 <code>open()</code> 函数的情况很少。在大部分 Ajax 编程的真实情况中，这种就绪状态的唯一用法就是使用相同的 <code>XMLHttpRequest</code> 对象在多个函数之间生成多个请求。在这种（不常见的）情况中，您可能会在生成新请求之前希望确保请求对象是处于未初始化状态（<code>readyState == 0</code>）。这实际上是要确保另外一个函数没有同时使用这个对象。</p> <p><a rel="nofollow"><span>查看正在处理的请求的就绪状态</span></a></p> <p>除了 0 就绪状态之外，请求对象还需要依次经历典型的请求和响应的其他几种就绪状态，最后才以就绪状态 4 的形式结束。这就是为什么您在大部分回调函数中都可以看到 <code>if (request.readyState == 4)</code> 这行代码；它确保服务器已经完成对请求的处理，现在可以安全地更新 Web 页面或根据从服务器返回来的数据来进行操作了。</p> <p>要查看这种状态发生的过程非常简单。如果就绪状态为 4，我们不仅要运行回调函数中的代码，而且还要在每次调用回调函数时都输出就绪状态。 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing3" rel="nofollow">清单 3</a> 给出了一个实现这种功能的例子。</p> <br><a rel="nofollow"><strong>清单 3. 查看就绪状态</strong></a><br> 
    <table> 
     <tbody> 
      <tr> 
       <td> <pre>   function updatePage() {
                        // Output the current ready state
                        alert("updatePage() called with ready state of " + request.readyState);
                        }
                        </pre> </td> 
      </tr> 
     </tbody> 
    </table><br><p>如果您不确定如何运行这个函数，就需要创建一个函数，然后在 Web 页面中调用这个函数，并让它向服务器端的组件发送一个请求（例如 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing2" rel="nofollow">清单 2</a> 给出的函数，或本系列文章的第 1 部分和第 2 部分中给出的例子）。确保在建立请求时，将回调函数设置为 <code>updatePage()</code>；要实现这种设置，可以将请求对象的 <code>onreadystatechange</code> 属性设置为 <code>updatePage()</code>。</p> <p>这段代码就是 <code>onreadystatechange</code> 意义的一个确切展示 —— 每次请求的就绪状态发生变化时，就调用 <code>updatePage()</code>，然后我们就可以看到一个警告了。<a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#fig2" rel="nofollow">图 2</a> 给出了一个调用这个函数的例子，其中就绪状态为 1。</p> <br><a rel="nofollow"><strong>图 2. 就绪状态 1</strong></a><br><img height="328" alt="就绪状态 1" src="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/ready-state_1.jpg" width="500"><br><p>您可以自己尝试运行这段代码。将其放入 Web 页面中，然后激活事件处理程序（单击按钮，在域之间按 tab 键切换焦点，或者使用设置的任何方法来触发请求）。这个回调函数会运行多次 —— 每次就绪状态都会改变 —— 您可以看到每个就绪状态的警告。这是跟踪请求所经历的各个阶段的最好方法。</p> <p><a rel="nofollow"><span>浏览器的不一致性</span></a></p> <p>在对这个过程有一个基本的了解之后，请试着从几个不同的浏览器中访问您的页面。您应该会注意到各个浏览器如何处理这些就绪状态并不一致。例如，在 Firefox 1.5 中，您会看到以下就绪状态：</p> 
    <ul> 
     <li>1 </li> 
     <li>2 </li> 
     <li>3 </li> 
     <li>4 </li> 
    </ul><p>这并不奇怪，因为每个请求状态都在这里表示出来了。然而，如果您使用 Safari 来访问相同的应用程序，就应该看到 —— 或者看不到 —— 一些有趣的事情。下面是在 Safari 2.0.1 中看到的状态：</p> 
    <ul> 
     <li>2 </li> 
     <li>3 </li> 
     <li>4 </li> 
    </ul><p>Safari 实际上把第一个就绪状态给丢弃了，也并没有什么明显的原因说明为什么要这样做；不过这就是 Safari 的工作方式。这还说明了一个重要的问题：<em>尽管在使用服务器上的数据之前确保请求的状态为 4 是一个好主意，但是依赖于每个过渡期就绪状态编写的代码的确会在不同的浏览器上得到不同的结果</em>。</p> <p>例如，在使用 Opera 8.5 时，所显示的就绪状态情况就更加糟糕了：</p> 
    <ul> 
     <li>3 </li> 
     <li>4 </li> 
    </ul><p>最后，Internet Explorer 会显示如下状态：</p> 
    <ul> 
     <li>1 </li> 
     <li>2 </li> 
     <li>3 </li> 
     <li>4 </li> 
    </ul><p>如果您碰到请求方面的问题，这就是用来发现问题的 <em>首要之处</em>。最好的方式是在 Internet Explorer 和 Firefox 都进行一下测试 —— 您会看到所有这 4 种状态，并可以检查请求的每个状态所处的情况。</p> <p>接下来我们再来看一下响应端的情况。</p> <p><a rel="nofollow"><span>显微镜下的响应数据</span></a></p> <p>一旦我们理解在请求过程中发生的各个就绪状态之后，接下来就可以来看一下 <code>XMLHttpRequest</code> 对象的另外一个方面了 —— <code>responseText</code> 属性。回想一下在上一篇文章中我们介绍过的内容，就可以知道这个属性用来从服务器上获取数据。一旦服务器完成对请求的处理之后，就可以将响应请求数据所需要的任何数据放到请求的 <code>responseText</code> 中了。然后回调函数就可以使用这些数据，如 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing1" rel="nofollow">清单 1</a> 和 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing4" rel="nofollow">清单 4</a> 所示。</p> <br><a rel="nofollow"><strong>清单 4. 使用服务器上返回的响应</strong></a><br> 
    <table> 
     <tbody> 
      <tr> 
       <td> <pre>   function updatePage() {
                        if (request.readyState == 4) {
                        var newTotal = request.responseText;
                        var totalSoldEl = document.getElementById("total-sold");
                        var netProfitEl = document.getElementById("net-profit");
                        replaceText(totalSoldEl, newTotal);
                        /* 图 out the new net profit */
                        var boardCostEl = document.getElementById("board-cost");
                        var boardCost = getText(boardCostEl);
                        var manCostEl = document.getElementById("man-cost");
                        var manCost = getText(manCostEl);
                        var profitPerBoard = boardCost - manCost;
                        var netProfit = profitPerBoard * newTotal;
                        /* Update the net profit on the sales form */
                        netProfit = Math.round(netProfit * 100) / 100;
                        replaceText(netProfitEl, netProfit);
                        }
                        </pre> </td> 
      </tr> 
     </tbody> 
    </table><br><p><a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing1" rel="nofollow">清单 1</a> 相当简单；<a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing4" rel="nofollow">清单 4</a> 稍微有点复杂，但是它们在开始时都要检查就绪状态，并获取 <code>responseText</code> 属性的值。</p> <p><a rel="nofollow"><span>查看请求的响应文本</span></a></p> <p>与就绪状态类似，<code>responseText</code> 属性的值在整个请求的生命周期中也会发生变化。要查看这种变化，请使用如 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing5" rel="nofollow">清单 5</a> 所示的代码来测试请求的响应文本，以及它们的就绪状态。</p> <br><a rel="nofollow"><strong>清单 5. 测试 responseText 属性</strong></a><br> 
    <table> 
     <tbody> 
      <tr> 
       <td> <pre>   function updatePage() {
                        // Output the current ready state
                        alert("updatePage() called with ready state of " + request.readyState +
                        " and a response text of '" + request.responseText + "'");
                        }
                        </pre> </td> 
      </tr> 
     </tbody> 
    </table><br><p>现在在浏览器中打开 Web 应用程序，并激活您的请求。要更好地看到这段代码的效果，请使用 Firefox 或 Internet Explorer，因为这两个浏览器都可以报告出请求过程中所有可能的就绪状态。例如在就绪状态 2 中，就没有定义 <code>responseText</code> （请参见 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#fig3" rel="nofollow">图 3</a>）；如果 JavaScript 控制台也已经打开了，您就会看到一个错误。</p> <br><a rel="nofollow"><strong>图 3. 就绪状态为 2 的响应文本</strong></a><br><img height="333" alt="就绪状态为 2 的响应文本" src="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/ready-state_2.jpg" width="500"><br><p>不过在就绪状态 3 中，服务器已经在 <code>responseText</code> 属性中放上了一个值，至少在这个例子中是这样（请参见 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#fig4" rel="nofollow">图 4</a>）。</p> <br><a rel="nofollow"><strong>图 4. 就绪状态为 3 的响应文本</strong></a><br><img height="334" alt="就绪状态为 3 的响应文本" src="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/ready-state_3.jpg" width="500"><br><p>您会看到就绪状态为 3 的响应在每个脚本、每个服务器甚至每个浏览器上都是不一样的。不过，这在调试应用程序中依然是非常有用的。</p> <p><a rel="nofollow"><span>获取安全数据</span></a></p> <p>所有的文档和规范都强调，只有在就绪状态为 4 时数据才可以安全使用。相信我，当就绪状态为 3 时，您很少能找到无法从 <code>responseText</code> 属性获取数据的情况。然而，在应用程序中将自己的逻辑依赖于就绪状态 3 可不是什么好主意 —— 一旦您编写了依赖于就绪状态 3 的完整数据的的代码，几乎就要自己来负责当时的数据不完整问题了。</p> <p>比较好的做法是向用户提供一些反馈，说明在处于就绪状态 3 时，很快就会有响应了。尽管使用 <code>alert()</code> 之类的函数显然不是什么好主意 —— 使用 Ajax 然后使用一个警告对话框来阻塞用户显然是错误的 —— 不过您可以在就绪状态发生变化时更新表单或页面中的域。例如，对于就绪状态 1 来说要将进度指示器的宽度设置为 25%，对于就绪状态 2 来说要将进度指示器的宽度设置为 50%，对于就绪状态 3 来说要将进度指示器的宽度设置为 75%，当就绪状态为 4 时将进度指示器的宽度设置为 100%（完成）。</p> <p>当然，正如您已经看到的一样，这种方法非常聪明，但它是依赖于浏览器的。在 Opera 上，您永远都不会看到前两个就绪状态，而在 Safari 上则没有第一个（1）。由于这个原因，我将这段代码留作练习，而没有在本文中包括进来。</p> <p>现在应该来看一下状态代码了。</p> <p><a rel="nofollow"><span>深入了解 HTTP 状态代码</span></a></p> <p>有了就绪状态和您在 Ajax 编程技术中学习到的服务器的响应，您就可以为 Ajax 应用程序添加另外一级复杂性了 —— 这要使用 HTTP 状态代码。这些代码对于 Ajax 来说并没有什么新鲜。从 Web 出现以来，它们就已经存在了。在 Web 浏览器中您可能已经看到过几个状态代码：</p> 
    <ul> 
     <li><strong>401</strong>：未经授权 </li> 
     <li><strong>403</strong>：禁止 </li> 
     <li><strong>404</strong>：没找到 </li> 
    </ul><p>您可以找到更多的状态代码（完整清单请参见 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#resources" rel="nofollow">参考资料</a>）。要为 Ajax 应用程序另外添加一层控制和响应（以及更为健壮的错误处理）机制，您需要适当地查看请求和响应中的状态代码。</p> <p><a rel="nofollow"><span>200：一切正常</span></a></p> <p>在很多 Ajax 应用程序中，您将看到一个回调函数，它负责检查就绪状态，然后继续利用从服务器响应中返回的数据，如 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing6" rel="nofollow">清单 6</a> 所示。</p> <br><a rel="nofollow"><strong>清单 6. 忽略状态代码的回调函数</strong></a><br> 
    <table> 
     <tbody> 
      <tr> 
       <td> <pre>   function updatePage() {
                        <span>if (request.readyState == 4) {
            </span>
                        var response = request.responseText.split("|");
                        document.getElementById("order").value = response[0];
                        document.getElementById("address").innerHTML =
                        response[1].replace(/\n/g, "&lt;br /&gt;");
                        }
                        }
                        </pre> </td> 
      </tr> 
     </tbody> 
    </table><br><p>这对于 Ajax 编程来说证明是一种短视而错误的方法。如果脚本需要认证，而请求却没有提供有效的证书，那么服务器就会返回诸如 403 或 401 之类的错误代码。然而，由于服务器对请求进行了应答，因此就绪状态就被设置为 4（即使应答并不是请求所期望的也是如此）。最终，用户没有获得有效数据，当 JavaScript 试图使用不存在的服务器数据时就可能会出现严重的错误。</p> <p>它花费了最小的努力来确保服务器不但完成了一个请求，而且还返回了一个 “一切良好” 的状态代码。这个代码是 "200"，它是通过 <code>XMLHttpRequest</code> 对象的 <code>status</code> 属性来报告的。为了确保服务器不但完成了一个请求，而且还报告了一个 OK 状态，请在您的回调函数中添加另外一个检查功能，如 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing7" rel="nofollow">清单 7</a> 所示。</p> <br><a rel="nofollow"><strong>清单 7. 检查有效状态代码</strong></a><br> 
    <table> 
     <tbody> 
      <tr> 
       <td> <pre>   function updatePage() {
                        if (request.readyState == 4) {
                        <span>       if (request.status == 200) {
            </span>
                        var response = request.responseText.split("|");
                        document.getElementById("order").value = response[0];
                        document.getElementById("address").innerHTML =
                        response[1].replace(/\n/g, "&lt;br /&gt;");
                        <span>       } else
                        alert("status is " + request.status);</span>
                        }
                        }
                        </pre> </td> 
      </tr> 
     </tbody> 
    </table><br><p>通过添加这几行代码，您就可以确认是否存在问题，用户会看到一个有用的错误消息，而不仅仅是看到一个由断章取义的数据所构成的页面，而没有任何解释。</p> <p><a rel="nofollow"><span>重定向和重新路由</span></a></p> <p>在深入介绍有关错误的内容之前，我们有必要来讨论一下有关一个在使用 Ajax 时 <em>并不需要</em> 关心的问题 —— 重定向。在 HTTP 状态代码中，这是 300 系列的状态代码，包括：</p> 
    <ul> 
     <li><strong>301</strong>：永久移动 </li> 
     <li><strong>302</strong>：找到（请求被重新定向到另外一个 URL/URI 上） </li> 
     <li><strong>305</strong>：使用代理（请求必须使用一个代理来访问所请求的资源） </li> 
    </ul><p>Ajax 程序员可能并不太关心有关重定向的问题，这是由于两方面的原因：</p> 
    <ul> 
     <li>首先，Ajax 应用程序通常都是为一个特定的服务器端脚本、servlet 或应用程序而编写的。对于那些您看不到就消失了的组件来说，Ajax 程序员就不太清楚了。因此有时您会知道资源已经移动了（因为您移动了它，或者通过某种手段移动了它），接下来要修改请求中的 URL，并且不会再碰到这种结果了。 </li> 
     <li>更为重要的一个原因是：Ajax 应用程序和请求都是封装在沙盒中的。这就意味着提供生成 Ajax 请求的 Web 页面的域必须是对这些请求进行响应的域。因此 ebay.com 所提供的 Web 页面就不能对一个在 amazon.com 上运行的脚本生成一个 Ajax 风格的请求；在 ibm.com 上的 Ajax 应用程序也无法对在 netbeans.org 上运行的 servlets 发出请求。 </li> 
    </ul><p>结果是您的请求无法重定向到其他服务器上，而不会产生安全性错误。在这些情况中，您根本就不会得到状态代码。通常在调试控制台中都会产生一个 JavaScript 错误。因此，在对状态代码进行充分的考虑之后，您就可以完全忽略重定向代码的问题了。</p> 
    <table> 
     <tbody> 
      <tr> 
       <td><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="10"></td> 
       <td> 
        <table> 
         <tbody> 
          <tr> 
           <td><a rel="nofollow"><strong>边界情况和困难情况</strong></a><br><p>看到现在，一些新手程序员就可能会这究竟是要讨论什么内容。有一点事实大家需要知道：只有不到 5% 的 Ajax 请求需要使用诸如 2、3 之类的就绪状态和诸如 403 之类的状态代码（实际上，这个比率可能更接近于 1% 甚至更少）。这些情况非常重要，称为 <em>边界情况（edge case）</em> —— 它们只会在一些非常特殊的情况下发生，其中遇到的都是最奇特的问题。虽然这些情况并不普遍，但是这些边界情况却占据了大部分用户所碰到的问题的 80%!</p> <p>对于典型的用户来说，应用程序 100 次都是正常工作的这个事实通常都会被忘记，然而应用程序只要一次出错就会被他们清楚地记住。如果您可以很好地处理边界情况（或困难情况），就可以为再次访问站点的用户提供满意的回报。</p> </td> 
          </tr> 
         </tbody> 
        </table></td> 
      </tr> 
     </tbody> 
    </table><p><a rel="nofollow"><span>错误</span></a></p> <p>一旦接收到状态代码 200 并且意识到可以很大程度上忽略 300 系列的状态代码之后，所需要担心的唯一一组代码就是 400 系列的代码了，这说明了不同类型的错误。回头再来看一下 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing7" rel="nofollow">清单 7</a>，并注意在对错误进行处理时，只将少数常见的错误消息输出给用户了。尽管这是朝正确方向前进的一步，但是要告诉从事应用程序开发的用户和程序员究竟发生了什么问题，这些消息仍然是没有太大用处的。</p> <p>首先，我们要添加对找不到的页的支持。实际上这在大部分产品系统中都不应该出现，但是在测试脚本位置发生变化或程序员输入了错误的 URL 时，这种情况并不罕见。如果您可以自然地报告 404 错误，就可以为那些困扰不堪的用户和程序员提供更多帮助。例如，如果服务器上的一个脚本被删除了，我们就可以使用 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing7" rel="nofollow">清单 7</a> 中的代码，这样用户就会看到一个如 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#fig5" rel="nofollow">图 5</a> 所示的非描述性错误。</p> <br><a rel="nofollow"><strong>图 5. 常见错误处理</strong></a><br><img height="376" alt="常见错误处理" src="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/generic_error.jpg" width="500"><br><p>用户无法判断问题究竟是认证问题、没找到脚本（此处就是这种情况）、用户错误还是代码中有些地方产生了问题。添加一些简单的代码可以让这个错误更加具体。请参照 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing8" rel="nofollow">清单 8</a>，它负责处理没找到的脚本或认证发生错误的情况，在出现这些错误时都会给出具体的消息。</p> <br><a rel="nofollow"><strong>清单 8. 检查有效状态代码</strong></a><br> 
    <table> 
     <tbody> 
      <tr> 
       <td> <pre>   function updatePage() {
                        if (request.readyState == 4) {
                        if (request.status == 200) {
                        var response = request.responseText.split("|");
                        document.getElementById("order").value = response[0];
                        document.getElementById("address").innerHTML =
                        response[1].replace(/\n/g, "&lt;br /&gt;");
                        <span>       } else if (request.status == 404) {
                        alert ("Requested URL is not found.");
                        } else if (request.status == 403) {
                        alert("Access denied.");</span>
                        } else
                        alert("status is " + request.status);
                        }
                        }
                        </pre> </td> 
      </tr> 
     </tbody> 
    </table><br><p>虽然这依然相当简单，但是它的确多提供了一些有用的信息。<a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#fig6" rel="nofollow">图 6</a> 给出了与 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#fig5" rel="nofollow">图 5</a> 相同的错误，但是这一次错误处理代码向用户或程序员更好地说明了究竟发生了什么。</p> <br><a rel="nofollow"><strong>图 6. 特殊错误处理</strong></a><br><img height="379" alt="特殊错误处理" src="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/specific_error.jpg" width="500"><br><p>在我们自己的应用程序中，可以考虑在发生认证失败的情况时清除用户名和密码，并向屏幕上添加一条错误消息。我们可以使用类似的方法来更好地处理找不到脚本或其他 400 类型的错误（例如 405 表示不允许使用诸如发送 HEAD 请求之类不可接受的请求方法，而 407 则表示需要进行代理认证）。然而不管采用哪种选择，都需要从对服务器上返回的状态代码开始入手进行处理。</p> <p><a rel="nofollow"><span>其他请求类型</span></a></p> <p>如果您真希望控制 <code>XMLHttpRequest</code> 对象，可以考虑最后实现这种功能 —— 将 HEAD 请求添加到指令中。在前两篇文章中，我们已经介绍了如何生成 GET 请求；在马上就要发表的一篇文章中，您会学习有关使用 POST 请求将数据发送到服务器上的知识。不过本着增强错误处理和信息搜集的精神，您应该学习如何生成 HEAD 请求。</p> <p><a rel="nofollow"><span>生成请求</span></a></p> <p>实际上生成 HEAD 请求非常简单；您可以使用 "HEAD"（而不是 "GET" 或 "POST"）作为第一个参数来调用 <code>open()</code> 方法，如 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing9" rel="nofollow">清单 9</a> 所示。</p> <br><a rel="nofollow"><strong>清单 9. 使用 Ajax 生成一个 HEAD 请求</strong></a><br> 
    <table> 
     <tbody> 
      <tr> 
       <td> <pre>   function getSalesData() {
                        createRequest();
                        var url = "/boards/servlet/UpdateBoardSales";
                        request.open(<span>"HEAD"</span>, url, true);
                        request.onreadystatechange = updatePage;
                        request.send(null);
                        }
                        </pre> </td> 
      </tr> 
     </tbody> 
    </table><br><p>当您这样生成一个 HEAD 请求时，服务器并不会像对 GET 或 POST 请求一样返回一个真正的响应。相反，服务器只会返回资源的 <em>头（header）</em>，这包括响应中内容最后修改的时间、请求资源是否存在和很多其他有用信息。您可以在服务器处理并返回资源之前使用这些信息来了解有关资源的信息。</p> <p>对于这种请求您可以做的最简单的事情就是简单地输出所有的响应头的内容。这可以让您了解通过 HEAD 请求可以使用什么。<a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing10" rel="nofollow">清单 10</a> 提供了一个简单的回调函数，用来输出从 HEAD 请求中获得的响应头的内容。</p> <br><a rel="nofollow"><strong>清单 10. 输出从 HEAD 请求中获得的响应头的内容</strong></a><br> 
    <table> 
     <tbody> 
      <tr> 
       <td> <pre>   function updatePage() {
                        if (request.readyState == 4) {
                        alert(request.getAllResponseHeaders());
                        }
                        }
                        </pre> </td> 
      </tr> 
     </tbody> 
    </table><br><p>请参见 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#fig7" rel="nofollow">图 7</a>，其中显示了从一个向服务器发出的 HEAD 请求的简单 Ajax 应用程序返回的响应头。</p> <br><a rel="nofollow"><strong>图 7. HEAD 请求的响应头</strong></a><br><img height="377" alt="HEAD 请求的响应头" src="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/response_headers.jpg" width="500"><br><p>您可以单独使用这些头（从服务器类型到内容类型）在 Ajax 应用程序中提供其他信息或功能。</p> <p><a rel="nofollow"><span>检查 URL</span></a></p> <p>您已经看到了当 URL 不存在时应该如何检查 404 错误。如果这变成一个常见的问题 —— 可能是缺少了一个特定的脚本或 servlet —— 那么您就可能会希望在生成完整的 GET 或 POST 请求之前来检查这个 URL。要实现这种功能，生成一个 HEAD 请求，然后在回调函数中检查 404 错误；<a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing11" rel="nofollow">清单 11</a> 给出了一个简单的回调函数。</p> <br><a rel="nofollow"><strong>清单 11. 检查某个 URL 是否存在</strong></a><br> 
    <table> 
     <tbody> 
      <tr> 
       <td> <pre>   function updatePage() {
                        if (request.readyState == 4) {
                        if (request.status == 200) {
                        alert("URL exists");
                        } else if (request.status == 404) {
                        alert("URL does not exist.");
                        } else {
                        alert("Status is: " + request.status);
                        }
                        }
                        }
                        </pre> </td> 
      </tr> 
     </tbody> 
    </table><br><p>诚实地说，这段代码的价值并不太大。服务器必须对请求进行响应，并构造一个响应来填充内容长度的响应头，因此并不能节省任何处理时间。另外，这花费的时间与生成请求并使用 HEAD 请求来查看 URL 是否存在所需要的时间一样多，因为它要生成使用 GET 或 POST 的请求，而不仅仅是如 <a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#listing7" rel="nofollow">清单 7</a> 所示一样来处理错误代码。不过，有时确切地了解目前什么可用也是非常有用的；您永远不会知道何时创造力就会迸发或者何时需要 HEAD 请求！</p> <p><a rel="nofollow"><span>有用的 HEAD 请求</span></a></p> <p>您会发现 HEAD 请求非常有用的一个领域是用来查看内容的长度或内容的类型。这样可以确定是否需要发回大量数据来处理请求，和服务器是否试图返回二进制数据，而不是 HTML、文本或 XML（在 JavaScript 中，这 3 种类型的数据都比二进制数据更容易处理）。</p> <p>在这些情况中，您只使用了适当的头名，并将其传递给 <code>XMLHttpRequest</code> 对象的 <code>getResponseHeader()</code> 方法。因此要获取响应的长度，只需要调用 <code>request.getResponseHeader("Content-Length");</code>。要获取内容类型，请使用 <code>request.getResponseHeader("Content-Type");</code>。</p> <p>在很多应用程序中，生成 HEAD 请求并没有增加任何功能，甚至可能会导致请求速度变慢（通过强制生成一个 HEAD 请求来获取有关响应的数据，然后在使用一个 GET 或 POST 请求来真正获取响应）。然而，在出现您不确定有关脚本或服务器端组件的情况时，使用 HEAD 请求可以获取一些基本的数据，而不需要对响应数据真正进行处理，也不需要大量的带宽来发送响应。</p> <p><a rel="nofollow"><span>结束语</span></a></p> <p>对于很多 Ajax 和 Web 程序员来说，本文中介绍的内容似乎是太高级了。生成 HEAD 请求的价值是什么呢？到底在什么情况下需要在 JavaScript 中显式地处理重定向状态代码呢？这些都是很好的问题；对于简单的应用程序来说，答案是这些高级技术的价值并不是非常大。</p> <p>然而，Web 已经不再是只需实现简单应用程序的地方了；用户已经变得更加高级，客户期望能够获得更好的稳定性、更高级的错误报告，如果应用程序有 1% 的时间停机，那么经理就可能会因此而被解雇。</p> <p>因此您的工作就不能仅仅局限于简单的应用程序了，而是需要更深入理解 <code>XMLHttpRequest</code>。</p> 
    <ul> 
     <li>如果您可以考虑各种就绪状态 —— 并且理解了这些就绪状态在不同浏览器之间的区别 —— 就可以快速调试应用程序了。您甚至可以基于就绪状态而开发一些创造性的功能，并向用户和客户回报请求的状态。 </li> 
     <li>如果您要对状态代码进行控制，就可以设置应用程序来处理脚本错误、非预期的响应以及边缘情况。结果是应用程序在所有的时间都可以正常工作，而不仅仅是只能一切都正常的情况下才能运行。 </li> 
     <li>增加这种生成 HEAD 请求的能力，检查某个 URL 是否存在，以及确认某个文件是否被修改过，这样就可以确保用户可以获得有效的页面，用户所看到的信息都是最新的，（最重要的是）让他们惊讶这个应用程序是如何健壮和通用。 </li> 
    </ul><p>本文的目的并非是要让您的应用程序显得十分华丽，而是帮助您去掉黄色聚光灯后重点昭显文字的美丽，或者外观更像桌面一样。尽管这些都是 Ajax 的功能（在后续几篇文章中就会介绍），不过它们却像是蛋糕表面的一层奶油。如果您可以使用 Ajax 来构建一个坚实的基础，让应用程序可以很好地处理错误和问题，用户就会返回您的站点和应用程序。在接下来的文章中，我们将添加这种直观的技巧，这会让客户兴奋得发抖。（认真地说，您一定不希望错过下一篇文章！）</p> <br><br> 
    <table> 
     <tbody> 
      <tr> 
       <td><img height="1" alt="" src="http://www.ibm.com/i/v14/rules/blue_rule.gif"><br><img height="6" alt="" src="http://www.ibm.com/i/c.gif" width="8"></td> 
      </tr> 
     </tbody> 
    </table> 
    <table> 
     <tbody> 
      <tr> 
       <td><img height="4" alt="" src="http://www.ibm.com/i/c.gif"><br> 
        <table> 
         <tbody> 
          <tr> 
           <td><img height="16" alt="" src="http://www.ibm.com/i/v14/icons/u_bold.gif" width="16"><br></td> 
           <td align="right"><a href="http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/#main" rel="nofollow"><strong>回页首</strong></a></td> 
          </tr> 
         </tbody> 
        </table></td> 
      </tr> 
     </tbody> 
    </table><br><br><p><span><a rel="nofollow">下载</a></span></p> 
    <table> 
     <tbody> 
      <tr> 
       <th>描述</th> 
       <th>名字</th> 
       <th align="right">大小</th> 
       <th>下载方法</th> 
      </tr> 
      <tr> 
       <th>Example code for this article</th> 
       <td>wa-ajaxintro3_ajax-xhr_adv.zip</td> 
       <td align="right">183KB</td> 
       <td><a href="http://download.boulder.ibm.com/ibmdl/pub/software/dw/web/%20wa-ajaxintro3_ajax-xhr_adv.zip" rel="nofollow"><strong>HTTP</strong></a></td> 
      </tr> 
     </tbody> 
    </table> 
    <table> 
     <tbody> 
      <tr> 
       <td colspan="5"><img height="12" alt="" src="http://www.ibm.com/i/c.gif" width="12"></td> 
      </tr> 
      <tr> 
       <td><img height="16" alt="" src="http://www.ibm.com/i/v14/icons/fw.gif" width="16"></td> 
       <td><a href="http://www.ibm.com/developerworks/cn/whichmethod.html" rel="nofollow">关于下载方法的信息</a></td> 
       <td><img height="1" alt="" src="http://www.ibm.com/i/c.gif" width="50"></td> 
      </tr> 
     </tbody> 
    </table></td> 
  </tr> 
 </tbody> 
</table>

TrackBack： http://www.ibm.com/developerworks/cn/xml/wa-ajaxintro3/

转载于:https://www.cnblogs.com/hdjjun/archive/2008/07/04/1235651.html