基于JAVA的ajax代理的研究实现

目录

• 前言
• ajax跨域问题描述
• ajax跨域问题解决方法
  • 解决方案一
  • 解决方案二
  • 解决方案三
  • 解决方案四
• 附录
  

前言

随着web2.0的发展，ajax变的越来越流行，并且已经深入到了许多web应用中。web2.0带来的还不仅仅是技术上和用户体验上的革新，更重要的 是他使互联网的信息更为开放，内容提供商们把私有的数据和服务通过web service（SOAP,REST）的方式暴露给他们的用户，用户可以遵循一定限制的基础上的对这些数据进行重新编排并展示。

ajax跨域问题描述

当数据位于同一个域内的时候ajax可以很容易的获取数据，如图一所示。但是很多人在尝试使用ajax去获取位于不同域的数据（例如yahoo的web service）会遇到了ajax不能跨域访问的问题，如图二所示。


图一 在同一个域中ajax获取服务器端数据没有问题



图二 ajax无法跨域获取位于yahoo域内的数据

    其实并不是ajax无法实现跨域访问，而是出于安全性的考虑，一般的浏览器都禁止了这个危险的操作。其实在新兴的RIA应用框架中，诸如adobe的air就可以通过ajax进行跨域访问（当然必须在air的sandbox限制之下）。

AJAX跨域问题的解决方法

解决方案一： 编写ajax web代理程

Ajax web代理即是在服务器端写一个代理程序将客户端请求重新打包再发送到目标服务器获取数据，如图三所示：


图三 ajax代理原理图


图四 ajax路由四种http请求原理图

名词解释：
    客户端：ajax请求的发起端。
    客户端请求方式：主要有GET，POST，PUT，DELETE四种基本HTTP请求方式
    请求参数：对于GET，PUT，DELETE请求，请求参数直接以query字段的形式写在URL里，POST的请求参数写在请求的body体中
    Ajax代理： ajax代理必须在ajax可以访问的域中。
    目标服务器：AJAX真实想访问的网址所在的服务器。
    目标服务器响应编码：即被请求的目标服务器响应时的编码方式。

应用场景 ：
用户需要在自己的应用中使用yahoo的news rss service，根据不同的查询，订阅新闻。
yahoo rss webservice的目标地址为http://news.search.yahoo.com/news/rss
查询参数为
p=查询参数，如“奥运”
ei=结果编码，如“GBK”
fl=0
x=wrt

使用ajax代理后的请求步骤：
（1）客户端请求AJAX代理
     客户端请求Ajax代理时，需要给出请求的目标地址和请求参数。
     对于get，put，delete方式的请求，请求参数是可以直接附着在url上的，示例代码如下，这里queryPath如果含有中文参数的话需要用 encodeURIComponent重新编码两次（至于为什么我也不太清楚，大家可以查看相关资料），否则ajax代理无法正确读取中文参数，出现乱码。

1. //构造查询连接字符串
2. var targetUrl = "http://news.search.yahoo.com/news/rss"
3. var queryPath = "p=奥运&ei=GBK&fl=0&x=wrt";
4. var url = "http://localhost/ajaxproxy?proxyReqUrl ="+targetUrl+"?"+encodeURIComponent(encodeURIComponent(queryPath));
5. //打开连接
6. xmlHttp.open("GET", url, true);
7. //设置回调函数
8. xmlHttp.onreadystatechange = callback();
9. //发送请求
10. xmlHttp.send(null);

     对于post方式的请求，请求参数写在请求体中。请求目标地址是 http://news.search.yahoo.com/news ，请求体中的请求参数是 p=奥运&ei=GBK&fl=0&x=wrt 。

    

1. //构造查询连接字符串
2. var targetUrl = "http://news.search.yahoo.com/news/rss"
3. var queryPath = "p=奥运&ei=GBK&fl=0&x=wrt";
4. var url = "http://localhost/ajaxproxy?proxyReqUrl="+targetUrl
5. //打开连接
6. xmlHttp.open("post", url, true);
7. //设置回调函数
8. xmlHttp.onreadystatechange = updatePage;
9. //设置服务器响应请求体参数
10. xmlHttp.setRequestHeader("Content-Type","application/x-www-form-urlencoded;"); 
11. //发送请求
12. xmlHttp.send(queryPath);

其中 http://localhost/ajaxproxy 为ajax代理，proxyReqUrl为客户端请求的目标地址。

（2）Ajax代理请求目标服务器
     ajax代理（通常是一个servlet）程序获取客户端请求的目标地址proxyReqUrl，请求参数，以及客户端的请求方式 （GET,POST,PUT,DELETE），并根据客户端请求方式将请求路由到目标服务器（有一些ajax代理不根据用户的请求方式，统一采用GET或者POST的方式提交用户请求，这样做会因为目标服务器无法接受这种请求获取不到数据，例如REST应用就是根据不同的请求方式来决定做什么操作返回什么样的数据的，因此请求方式决定了restful webservice的行为方式）。
以下程序是一个典型的ajax代理实现：

1. package ajax.proxy.web;
2. 
   
3. import java.io.IOException;
4. import java.io.PrintWriter;
5. import java.net.URLDecoder;
6. import java.net.URLEncoder;
7. import java.util.Enumeration;
8. import java.util.HashMap;
9. import java.util.Map;
10. 
    
11. import javax.servlet.ServletException;
12. import javax.servlet.http.HttpServlet;
13. import javax.servlet.http.HttpServletRequest;
14. import javax.servlet.http.HttpServletResponse;
15. 
    
16. import org.apache.commons.httpclient.DefaultHttpMethodRetryHandler;
17. import org.apache.commons.httpclient.HttpClient;
18. import org.apache.commons.httpclient.HttpException;
19. import org.apache.commons.httpclient.HttpStatus;
20. import org.apache.commons.httpclient.methods.GetMethod;
21. import org.apache.commons.httpclient.params.HttpMethodParams;
22. 
    
23. import ajax.proxy.*;
24. 
    
25. public class AjaxProxyServlet extends HttpServlet {
26.        /** 
27.         * Processes requests for both HTTP <code>GET</code> and <code>POST</code> and <code>PUT</code> and <code>DELETE</code> methods.
28.         * @param request servlet request
29.         * @param response servlet response
30.         */
31.         protected void processRequest(HttpServletRequest request, HttpServletResponse response)
32.         throws ServletException, IOException {
33.               //请求参数
34.               Map<String,String> params = new HashMap<String,String>();
35.               //客户端请求方式
36.               String method = request.getMethod();
37.               //目标服务器响应的编码
38.               String encoding = "UTF-8";
39.               //目标服务器地址
40.               String url = null;
41.               //获取参数键值名称 
42.               Enumeration<String> enu = request.getParameterNames();
43.     
44.               while (enu.hasMoreElements()) {
45.                     // 取得参数名称列表
46.                     String paramName=(String)enu.nextElement();
47.                     // 处理本请求参数以及发送给第三方服务器的参数
48.                     if(paramName.equals("ajaxReqUrl")){
49.                         try {
50.                            // 获取目标服务器地址，并对目标服务器中的中文进行重新编码
51.                            url=ProxyUtils.rebuildURL(URLDecoder.decode(request.getParameter(paramName),"utf-8"), "gbk");
52.                         } catch (Exception e) {
53.                            e.printStackTrace();
54.                         }
55.                      }else{
56.                         String aParamValue = request.getParameter(paramName);
57.                         params.put(paramName, aParamValue);
58.                     }
59.              }
60.               //取得ajax代理
61.               AjaxProxy proxy = ProxyFactory.getProxyInstance(method,url,params,encoding);
62.               //获取ajax代理响应
63.               AjaxResponse resp = proxy.getAjaxResponse();
64.               //输出必须用UTF-8编码
65.               response.setCharacterEncoding("UTF-8");
66.               PrintWriter out = response.getWriter();
67.               System.out.println(url);
68.               out.println(resp.getContent());             
69.         } 
70. 
    
71.        
72.         /** 
73.         * Handles the HTTP <code>GET</code> method.
74.         * @param request servlet request
75.         * @param response servlet response
76.         */
77.         protected void doGet(HttpServletRequest request, HttpServletResponse response)
78.         throws ServletException, IOException {
79.             processRequest(request, response);
80.         } 
81. 
    
82.         /** 
83.         * Handles the HTTP <code>POST</code> method.
84.         * @param request servlet request
85.         * @param response servlet response
86.         */
87.         protected void doPost(HttpServletRequest request, HttpServletResponse response)
88.         throws ServletException, IOException {
89.             processRequest(request, response);
90.         }
91.         
92.         protected void doDelete(HttpServletRequest request, HttpServletResponse response)
93.         throws ServletException, IOException {
94.             processRequest(request, response);
95.         }
96.         
97.         protected void doPut(HttpServletRequest request, HttpServletResponse response)
98.         throws ServletException, IOException {
99.             processRequest(request, response);
100.         }
101. 
     
102.         /** 
103.         * Returns a short description of the servlet.
104.         */
105.         public String getServletInfo() {
106.             return "Short description";
107.         }
108. }
109. 
     

程序开始时候先获得用户请求方式method, 请求目标地址url,请求参数params，再根据目标地址的响应编码（一般都预先得知），通过这四个参数从proxyFactory中获取合适的proxy，并调用getAjaxResponse方法来获得目标地址响应。

1. //取得ajax代理
2. AjaxProxy proxy = ProxyFactory.getProxyInstance(method,url,params,encoding);
3. //获取ajax代理响应
4. AjaxResponse resp = proxy.getAjaxResponse();

这里proxy主要有四种，本文采用了apache开源项目HttpClient来路由请求。

• GetProxy
• PostProxy
• PutProxy
• DeleteProxy

他们都继承于AjaxProxy类：

1. package ajax.proxy;
3. import java.io.IOException;
4. import java.util.*;
6. public abstract class AjaxProxy {
7.     //请求目标地址
8.     protected String url;
9.     //请求参数
10.     protected Map<String,String> params;
11.     //目标地址返回响应的编码
12.     protected String encoding;
13.     
14.     public AjaxProxy(String url, Map<String,String> params,
15.             String encoding) {
16.         super();
17.         this.url = url;
18.         this.params = params;
19.         this.encoding = encoding;
20.     }
21.     /*
22.      * 抽象方法，GetProxy，PostProxy，PutProxy，DeleteProxy各自实现这个方法，
23.      * 返回的是AjaxResponse对象
24.      */
25.     public abstract AjaxResponse getAjaxResponse();
27.     public String getEncoding() {
28.         return encoding;
29.     }
31.     public void setEncoding(String encoding) {
32.         this.encoding = encoding;
33.     }
34. }

Proxy工厂类，根据请求方法，请求目标地址，请求参数，目标响应编码来生产不同的代理。

1. package ajax.proxy;
3. import java.util.Map;
5. public class ProxyFactory {
6.         
7.     public static AjaxProxy getProxyInstance(String method, String url, Map<String, String> params, String encoding){
8.         AjaxProxy proxy = null;
9.         if("GET".equalsIgnoreCase(method)){
10.             proxy = new GetProxy(url, null, encoding);
11.         }else if("POST".equalsIgnoreCase(method)){
12.             proxy = new PostProxy(url, params, encoding);
13.         }else if("PUT".equalsIgnoreCase(method)){
14.             proxy = new PutProxy(url, params, encoding);
15.         }else if("DELETE".equalsIgnoreCase(method)){
16.             proxy = new DeleteProxy(url, null, encoding);
17.         }
18.         return proxy;
19.     }
20. }

以GetProxy为例，他是路由用户的Get请求，代码如下：

1. package ajax.proxy;
2. import java.io.IOException;
3. import java.util.*;
5. import org.apache.commons.httpclient.*;
6. import org.apache.commons.httpclient.methods.GetMethod;
7. import org.apache.commons.httpclient.params.HttpMethodParams;
9. public class GetProxy extends AjaxProxy {
11.     public GetProxy(String url, Map<String, String> params, String encoding) {
12.         super(url, params, encoding);
13.         // TODO Auto-generated constructor stub
14.     }
16.     public AjaxResponse getAjaxResponse() {
18.           //构造HttpClient的实例
19.           HttpClient httpClient = new HttpClient();
20.           //httpClient.getParams().setUriCharset("GBK");
21.           //创建GET方法的实例
22.           GetMethod getMethod = new GetMethod(url);
23.           
24.           //使用系统提供的默认的恢复策略
25.           getMethod.getParams().setParameter(HttpMethodParams.RETRY_HANDLER,
26.             new DefaultHttpMethodRetryHandler());
27.           try {
28.            //执行getMethod
29.            int statusCode = httpClient.executeMethod(getMethod);
30.            System.out.println(getMethod.getStatusLine());
31.            if (statusCode != HttpStatus.SC_OK) {
32.                return new AjaxResponse(statusCode, "");
33.            }
34.            //读取内容 
35.            byte[] responseBody = getMethod.getResponseBody();
36.            //处理内容
37.            return new AjaxResponse(statusCode, new String(responseBody, encoding));
38.           } catch (HttpException e) {
39.            //发生致命的异常，可能是协议不对或者返回的内容有问题
40.            System.out.println("Please check your provided http address!");
41.            e.printStackTrace();
42.           } catch (IOException e) {
43.            //发生网络异常
44.            e.printStackTrace();
45.           } finally {
46.            //释放连接
47.            getMethod.releaseConnection();
48.           }
49.           return new AjaxResponse(AjaxResponse.EXCEPTIONERROR, "");
50.     }
51. }

全部代码将在本文最后附录中提供下载。

解决方案二：

使用阿帕奇的 mod_rewrite   or   mod_proxy 来从你的服务器上转发到另外的服务器 . 在你的客户端代码中你只要做请求就可以了 , 就好象工作在你自己的服务器上------- 不会有浏览器的限制问题 . 然后阿帕奇会神奇的为你请求其他服务器 .

解决方案三：

使用 json 或者动态 <script> 标记来替代 xml 和 XMLHttpRequest. 你可以通过直接在 <script> 标记内发送你的 web 服务请求 , 这样就可以完全绕过浏览器的安全限制 . 你使用的 yahoo 服务能够输出 JSON( 使用 output=json 和 callback=function 参数 ), 当页面加载完成后从 web 服务返回的数据已经被优化为 javascript 对象。

解决方案四：

对你的脚本进行数字签名. 在 FireFox 中 , 你可以为你的脚本和那些信任站点的脚本申请一个数字签名 . 这样 FireFox 就会允许你通过 XMLHttpRequest 访问任何的域 . 但是 , 其他浏览器不支持这种方式的脚本签名,所以,这种解决方案会受限.

附录：

本文涉及的ajax代理源代码