2010-10-02 85 views
0

我正在使用GWT RPC連接到服務器端。在服務器端,我必須連接到MySQL數據庫,從中獲取我需要的數據。我的問題是,當我想測試我的應用程序時,最好的做法是什麼,因爲我還沒有在Tomcat應用程序服務器上部署它,而且似乎我無法測試它,如果它沒有部署。當我在開發模式下測試它時,我無法連接到數據庫。我是否必須在Tomcat上部署它來測試我的應用程序,或者有任何其他方法。GWT RPC測試數據庫連接

P.S.我包含JDBC驅動程序,所以這不是問題。

+0

你應該能夠到Tomcat外測試與數據庫的應用程序。你遇到了什麼錯誤? – Pace 2010-10-02 00:45:07

回答

0

真的不知道你在這個時候遇到什麼問題,因爲你沒有任何異常張貼的,但我按照最佳做法,當我測試我在開發模式下的GWT代碼是將來自GWT的請求代理到在不同應用程序服務器上運行的後端實現。既然你打算把你的代碼移動到tomcat上,我假設你將把你的GWT編譯代碼移動到在tomcat上運行的J2EE項目的war目錄下,並且實際的db調用將從這個J2EE項目完成。按照以下步驟。

基本上,在您的GWT應用程序中,在「服務器」端,您需要創建代理servlet,將所有請求代理到不同的端口(運行後端應用程序的端口 - 例如tomcat的端口)。

您將需要同時運行兩個應用程序(顯然是在不同的端口上)。這樣,當你處於GWT開發模式時,所有的請求首先被髮送到碼頭應用服務器,然後被轉發到tomcat,這就是你如何繼續測試而不需要來回複製文件並測試你的真實後端實現。

代理Servlet(從http://edwardstx.net/wiki/attach/HttpProxyServlet/ProxyServlet.java


package com.xxxxxxx.xxxxx.gwt.xxxxx.server; 


import java.io.BufferedReader; 
import java.io.ByteArrayInputStream; 
import java.io.ByteArrayOutputStream; 
import java.io.File; 
import java.io.IOException; 
import java.io.UnsupportedEncodingException; 
import java.util.ArrayList; 
import java.util.Arrays; 
import java.util.Enumeration; 
import java.util.List; 
import java.util.Map; 
import java.util.zip.GZIPInputStream; 

import javax.servlet.ServletConfig; 
import javax.servlet.ServletException; 
import javax.servlet.http.Cookie; 
import javax.servlet.http.HttpServlet; 
import javax.servlet.http.HttpServletRequest; 
import javax.servlet.http.HttpServletResponse; 

import org.apache.commons.httpclient.Header; 
import org.apache.commons.httpclient.HttpClient; 
import org.apache.commons.httpclient.HttpMethod; 
import org.apache.commons.httpclient.NameValuePair; 
import org.apache.commons.httpclient.methods.GetMethod; 
import org.apache.commons.httpclient.methods.PostMethod; 
import org.apache.commons.httpclient.methods.StringRequestEntity; 

/** 
* ProxyServlet from http://edwardstx.net/wiki/attach/HttpProxyServlet/ProxyServlet.java 
* (This seems to be a derivative of Noodle -- http://noodle.tigris.org/) 
* 
* Patched to skip "Transfer-Encoding: chunked" headers, avoid double slashes 
* in proxied URLs, handle GZip and allow GWT RPC. 
*/ 
public class ProxyServlet extends HttpServlet { 

    private static final int FOUR_KB = 4196; 

    /** 
    * Serialization UID. 
    */ 
    private static final long serialVersionUID = 1L; 
    /** 
    * Key for redirect location header. 
    */ 
    private static final String STRING_LOCATION_HEADER = "Location"; 
    /** 
    * Key for content type header. 
    */ 
    private static final String STRING_CONTENT_TYPE_HEADER_NAME = "Content-Type"; 
    /** 
    * Key for content length header. 
    */ 
    private static final String STRING_CONTENT_LENGTH_HEADER_NAME = "Content-Length"; 
    /** 
    * Key for host header 
    */ 
    private static final String STRING_HOST_HEADER_NAME = "Host"; 
    /** 
    * The directory to use to temporarily store uploaded files 
    */ 
    private static final File FILE_UPLOAD_TEMP_DIRECTORY = new File(System.getProperty("java.io.tmpdir")); 

    // Proxy host params 
    /** 
    * The host to which we are proxying requests. Default value is "localhost". 
    */ 
    private String stringProxyHost = "localhost"; 
    /** 
    * The port on the proxy host to wihch we are proxying requests. Default value is 80. 
    */ 
    private int intProxyPort = 80; 
    /** 
    * The (optional) path on the proxy host to wihch we are proxying requests. Default value is "". 
    */ 
    private String stringProxyPath = ""; 
    /** 
    * Setting that allows removing the initial path from client. Allows specifying /twitter/* as synonym for twitter.com. 
    */ 
    private boolean removePrefix; 
    /** 
    * The maximum size for uploaded files in bytes. Default value is 5MB. 
    */ 
    private int intMaxFileUploadSize = 5 * 1024 * 1024; 
    private boolean isSecure; 
    private boolean followRedirects; 

    /** 
    * Initialize the ProxyServlet 
    * @param servletConfig The Servlet configuration passed in by the servlet container 
    */ 
    public void init(ServletConfig servletConfig) { 
     // Get the proxy host 
     String stringProxyHostNew = servletConfig.getInitParameter("proxyHost"); 
     if (stringProxyHostNew == null || stringProxyHostNew.length() == 0) { 
      throw new IllegalArgumentException("Proxy host not set, please set init-param 'proxyHost' in web.xml"); 
     } 
     this.setProxyHost(stringProxyHostNew); 
     // Get the proxy port if specified 
     String stringProxyPortNew = servletConfig.getInitParameter("proxyPort"); 
     if (stringProxyPortNew != null && stringProxyPortNew.length() > 0) { 
      this.setProxyPort(Integer.parseInt(stringProxyPortNew)); 
     } 
     // Get the proxy path if specified 
     String stringProxyPathNew = servletConfig.getInitParameter("proxyPath"); 
     if (stringProxyPathNew != null && stringProxyPathNew.length() > 0) { 
      this.setProxyPath(stringProxyPathNew); 
     } 
     // Get the maximum file upload size if specified 
     String stringMaxFileUploadSize = servletConfig.getInitParameter("maxFileUploadSize"); 
     if (stringMaxFileUploadSize != null && stringMaxFileUploadSize.length() > 0) { 
      this.setMaxFileUploadSize(Integer.parseInt(stringMaxFileUploadSize)); 
     } 
    } 

    /** 
    * Performs an HTTP GET request 
    * @param httpServletRequest The {@link HttpServletRequest} object passed 
    *       in by the servlet engine representing the 
    *       client request to be proxied 
    * @param httpServletResponse The {@link HttpServletResponse} object by which 
    *        we can send a proxied response to the client 
    */ 
    public void doGet(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) 
      throws IOException, ServletException { 
     // Create a GET request 
     String destinationUrl = this.getProxyURL(httpServletRequest); 
     debug("GET Request URL: " + httpServletRequest.getRequestURL(), 
       "Destination URL: " + destinationUrl); 
     GetMethod getMethodProxyRequest = new GetMethod(destinationUrl); 
     // Forward the request headers 
     setProxyRequestHeaders(httpServletRequest, getMethodProxyRequest); 
     setProxyRequestCookies(httpServletRequest, getMethodProxyRequest); 
     // Execute the proxy request 
     this.executeProxyRequest(getMethodProxyRequest, httpServletRequest, httpServletResponse); 
    } 

    /** 
    * Performs an HTTP POST request 
    * @param httpServletRequest The {@link HttpServletRequest} object passed 
    *       in by the servlet engine representing the 
    *       client request to be proxied 
    * @param httpServletResponse The {@link HttpServletResponse} object by which 
    *        we can send a proxied response to the client 
    */ 
    public void doPost(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) 
      throws IOException, ServletException { 
     // Create a standard POST request 
     String contentType = httpServletRequest.getContentType(); 
     String destinationUrl = this.getProxyURL(httpServletRequest); 
     debug("POST Request URL: " + httpServletRequest.getRequestURL(), 
       " Content Type: " + contentType, 
       " Destination URL: " + destinationUrl); 
     PostMethod postMethodProxyRequest = new PostMethod(destinationUrl); 
     // Forward the request headers 
     setProxyRequestHeaders(httpServletRequest, postMethodProxyRequest); 
     setProxyRequestCookies(httpServletRequest, postMethodProxyRequest); 
     // Check if this is a mulitpart (file upload) POST 

      if (contentType == null || PostMethod.FORM_URL_ENCODED_CONTENT_TYPE.equals(contentType)) { 
       this.handleStandardPost(postMethodProxyRequest, httpServletRequest); 
      } else { 
       this.handleContentPost(postMethodProxyRequest, httpServletRequest); 
      } 

     // Execute the proxy request 
     this.executeProxyRequest(postMethodProxyRequest, httpServletRequest, httpServletResponse); 
    } 



    /** 
    * Sets up the given {@link PostMethod} to send the same standard POST 
    * data as was sent in the given {@link HttpServletRequest} 
    * @param postMethodProxyRequest The {@link PostMethod} that we are 
    *        configuring to send a standard POST request 
    * @param httpServletRequest The {@link HttpServletRequest} that contains 
    *       the POST data to be sent via the {@link PostMethod} 
    */ 
    @SuppressWarnings("unchecked") 
    private void handleStandardPost(PostMethod postMethodProxyRequest, HttpServletRequest httpServletRequest) { 
     // Get the client POST data as a Map 
     Map mapPostParameters = (Map) httpServletRequest.getParameterMap(); 
     // Create a List to hold the NameValuePairs to be passed to the PostMethod 
     List listNameValuePairs = new ArrayList(); 
     // Iterate the parameter names 
     for (String stringParameterName : mapPostParameters.keySet()) { 
      // Iterate the values for each parameter name 
      String[] stringArrayParameterValues = mapPostParameters.get(stringParameterName); 
      for (String stringParamterValue : stringArrayParameterValues) { 
       // Create a NameValuePair and store in list 
       NameValuePair nameValuePair = new NameValuePair(stringParameterName, stringParamterValue); 
       listNameValuePairs.add(nameValuePair); 
      } 
     } 
     // Set the proxy request POST data 
     postMethodProxyRequest.setRequestBody(listNameValuePairs.toArray(new NameValuePair[]{})); 
    } 

    /** 
    * Sets up the given {@link PostMethod} to send the same content POST 
    * data (JSON, XML, etc.) as was sent in the given {@link HttpServletRequest} 
    * @param postMethodProxyRequest The {@link PostMethod} that we are 
    *        configuring to send a standard POST request 
    * @param httpServletRequest The {@link HttpServletRequest} that contains 
    *       the POST data to be sent via the {@link PostMethod} 
    */ 
    private void handleContentPost(PostMethod postMethodProxyRequest, HttpServletRequest httpServletRequest) throws IOException, ServletException { 
     StringBuilder content = new StringBuilder(); 
     BufferedReader reader = httpServletRequest.getReader(); 
     for (;;) { 
      String line = reader.readLine(); 
      if (line == null) break; 
      content.append(line); 
     } 

     String contentType = httpServletRequest.getContentType(); 
     String postContent = content.toString(); 

     if (contentType.startsWith("text/x-gwt-rpc")) { 
      String clientHost = httpServletRequest.getLocalName(); 
      if (clientHost.equals("127.0.0.1")) { 
       clientHost = "localhost"; 
      } 

      int clientPort = httpServletRequest.getLocalPort(); 
      String clientUrl = clientHost + ((clientPort != 80) ? ":" + clientPort : ""); 
      String serverUrl = stringProxyHost + ((intProxyPort != 80) ? ":" + intProxyPort : "") + httpServletRequest.getServletPath(); 
      //debug("Replacing client (" + clientUrl + ") with server (" + serverUrl + ")"); 
      postContent = postContent.replace(clientUrl , serverUrl); 
     } 

     String encoding = httpServletRequest.getCharacterEncoding(); 
     debug("POST Content Type: " + contentType + " Encoding: " + encoding, 
       "Content: " + postContent); 
     StringRequestEntity entity; 
     try { 
      entity = new StringRequestEntity(postContent, contentType, encoding); 
     } catch (UnsupportedEncodingException e) { 
      throw new ServletException(e); 
     } 
     // Set the proxy request POST data 
     postMethodProxyRequest.setRequestEntity(entity); 
    } 

    /** 
    * Executes the {@link HttpMethod} passed in and sends the proxy response 
    * back to the client via the given {@link HttpServletResponse} 
    * @param httpMethodProxyRequest An object representing the proxy request to be made 
    * @param httpServletResponse An object by which we can send the proxied 
    *        response back to the client 
    * @throws IOException Can be thrown by the {@link HttpClient}.executeMethod 
    * @throws ServletException Can be thrown to indicate that another error has occurred 
    */ 
    private void executeProxyRequest(
      HttpMethod httpMethodProxyRequest, 
      HttpServletRequest httpServletRequest, 
      HttpServletResponse httpServletResponse) 
      throws IOException, ServletException { 
     // Create a default HttpClient 
     HttpClient httpClient = new HttpClient(); 
     httpMethodProxyRequest.setFollowRedirects(false); 
     // Execute the request 
     int intProxyResponseCode = httpClient.executeMethod(httpMethodProxyRequest); 
     String response = httpMethodProxyRequest.getResponseBodyAsString(); 

     // Check if the proxy response is a redirect 
     // The following code is adapted from org.tigris.noodle.filters.CheckForRedirect 
     // Hooray for open source software 
     if (intProxyResponseCode >= HttpServletResponse.SC_MULTIPLE_CHOICES /* 300 */ && intProxyResponseCode responseHeaders = Arrays.asList(headerArrayResponse); 

     if (isBodyParameterGzipped(responseHeaders)) { 
      debug("GZipped: true"); 
      if (!followRedirects && intProxyResponseCode == HttpServletResponse.SC_MOVED_TEMPORARILY) { 
       response = httpMethodProxyRequest.getResponseHeader(STRING_LOCATION_HEADER).getValue(); 
       httpServletResponse.setStatus(HttpServletResponse.SC_OK); 
       intProxyResponseCode = HttpServletResponse.SC_OK; 
       httpServletResponse.setHeader(STRING_LOCATION_HEADER, response); 
      } else { 
       response = new String(ungzip(httpMethodProxyRequest.getResponseBody())); 
      } 
      httpServletResponse.setContentLength(response.length()); 
     } 

     // Send the content to the client 
     debug("Received status code: " + intProxyResponseCode, 
       "Response: " + response); 

     httpServletResponse.getWriter().write(response); 
    } 


    /** 
    * The response body will be assumed to be gzipped if the GZIP header has been set. 
    * 
    * @param responseHeaders of response headers 
    * @return true if the body is gzipped 
    */ 
    private boolean isBodyParameterGzipped(List responseHeaders) { 
     for (Header header : responseHeaders) { 
      if (header.getValue().equals("gzip")) { 
       return true; 
      } 
     } 
     return false; 
    } 

    /** 
    * A highly performant ungzip implementation. Do not refactor this without taking new timings. 
    * See ElementTest in ehcache for timings 
    * 
    * @param gzipped the gzipped content 
    * @return an ungzipped byte[] 
    * @throws java.io.IOException when something bad happens 
    */ 
    private byte[] ungzip(final byte[] gzipped) throws IOException { 
     final GZIPInputStream inputStream = new GZIPInputStream(new ByteArrayInputStream(gzipped)); 
     ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(gzipped.length); 
     final byte[] buffer = new byte[FOUR_KB]; 
     int bytesRead = 0; 
     while (bytesRead != -1) { 
      bytesRead = inputStream.read(buffer, 0, FOUR_KB); 
      if (bytesRead != -1) { 
       byteArrayOutputStream.write(buffer, 0, bytesRead); 
      } 
     } 
     byte[] ungzipped = byteArrayOutputStream.toByteArray(); 
     inputStream.close(); 
     byteArrayOutputStream.close(); 
     return ungzipped; 
    } 

    public String getServletInfo() { 
     return "GWT Proxy Servlet"; 
    } 

    /** 
    * Retrieves all of the headers from the servlet request and sets them on 
    * the proxy request 
    * 
    * @param httpServletRequest The request object representing the client's 
    *       request to the servlet engine 
    * @param httpMethodProxyRequest The request that we are about to send to 
    *        the proxy host 
    */ 
    @SuppressWarnings("unchecked") 
    private void setProxyRequestHeaders(HttpServletRequest httpServletRequest, HttpMethod httpMethodProxyRequest) { 
     // Get an Enumeration of all of the header names sent by the client 
     Enumeration enumerationOfHeaderNames = httpServletRequest.getHeaderNames(); 
     while (enumerationOfHeaderNames.hasMoreElements()) { 
      String stringHeaderName = (String) enumerationOfHeaderNames.nextElement(); 
      if (stringHeaderName.equalsIgnoreCase(STRING_CONTENT_LENGTH_HEADER_NAME)) { 
       continue; 
      } 
      // As per the Java Servlet API 2.5 documentation: 
      //  Some headers, such as Accept-Language can be sent by clients 
      //  as several headers each with a different value rather than 
      //  sending the header as a comma separated list. 
      // Thus, we get an Enumeration of the header values sent by the client 
      Enumeration enumerationOfHeaderValues = httpServletRequest.getHeaders(stringHeaderName); 
      while (enumerationOfHeaderValues.hasMoreElements()) { 
       String stringHeaderValue = (String) enumerationOfHeaderValues.nextElement(); 
       // In case the proxy host is running multiple virtual servers, 
       // rewrite the Host header to ensure that we get content from 
       // the correct virtual server 
       if (stringHeaderName.equalsIgnoreCase(STRING_HOST_HEADER_NAME)) { 
        stringHeaderValue = getProxyHostAndPort(); 
       } 
       Header header = new Header(stringHeaderName, stringHeaderValue); 
       // Set the same header on the proxy request 
       httpMethodProxyRequest.setRequestHeader(header); 
      } 
     } 
    } 

    /** 
    * Retrieves all of the cookies from the servlet request and sets them on 
    * the proxy request 
    * 
    * @param httpServletRequest The request object representing the client's 
    *       request to the servlet engine 
    * @param httpMethodProxyRequest The request that we are about to send to 
    *        the proxy host 
    */ 
    @SuppressWarnings("unchecked") 
    private void setProxyRequestCookies(HttpServletRequest httpServletRequest, HttpMethod httpMethodProxyRequest) { 
     // Get an array of all of all the cookies sent by the client 
     Cookie[] cookies = httpServletRequest.getCookies(); 
     if (cookies == null) { 
      return; 
     } 

     for (Cookie cookie : cookies) { 
      cookie.setDomain(stringProxyHost); 
      cookie.setPath(httpServletRequest.getServletPath()); 
      httpMethodProxyRequest.setRequestHeader("Cookie", cookie.getName() + "=" + cookie.getValue() + "; Path=" + cookie.getPath()); 
     } 
    } 

    // Accessors 
    private String getProxyURL(HttpServletRequest httpServletRequest) { 
     // Set the protocol to HTTP 
     String protocol = (isSecure) ? "https://" : "http://"; 
     String stringProxyURL = protocol + this.getProxyHostAndPort() + "/gui"; 

     // simply use whatever servlet path that was part of the request as opposed to getting a preset/configurable proxy path 
     if (!removePrefix) { 
      if (httpServletRequest.getServletPath() != null) { 
       stringProxyURL += httpServletRequest.getServletPath();    
      } 
     } 
     stringProxyURL += "/"; 

     // Handle the path given to the servlet 
     String pathInfo = httpServletRequest.getPathInfo(); 
     if (pathInfo != null && pathInfo.startsWith("/")) { 
      if (stringProxyURL != null && stringProxyURL.endsWith("/")) { 
       // avoid double '/' 
       stringProxyURL += pathInfo.substring(1); 
      } 
     } else { 
      stringProxyURL += httpServletRequest.getPathInfo(); 
     } 
     // Handle the query string 
     if (httpServletRequest.getQueryString() != null) { 
      stringProxyURL += "?" + httpServletRequest.getQueryString(); 
     } 

     stringProxyURL = stringProxyURL.replaceAll("/null", ""); 
     //System.out.println("----stringProxyURL: " + stringProxyURL); 
     return stringProxyURL; 
    } 

    private String getProxyHostAndPort() { 
     if (this.getProxyPort() == 80) { 
      return this.getProxyHost(); 
     } else { 
      return this.getProxyHost() + ":" + this.getProxyPort(); 
     } 
    } 

    protected String getProxyHost() { 
     return this.stringProxyHost; 
    } 

    protected void setProxyHost(String stringProxyHostNew) { 
     this.stringProxyHost = stringProxyHostNew; 
    } 

    protected int getProxyPort() { 
     return this.intProxyPort; 
    } 

    protected void setSecure(boolean secure) { 
     this.isSecure = secure; 
    } 

    protected void setFollowRedirects(boolean followRedirects) { 
     this.followRedirects = followRedirects; 
    } 

    protected void setProxyPort(int intProxyPortNew) { 
     this.intProxyPort = intProxyPortNew; 
    } 

    protected String getProxyPath() { 
     return this.stringProxyPath; 
    } 

    protected void setProxyPath(String stringProxyPathNew) { 
     this.stringProxyPath = stringProxyPathNew; 
    } 

    protected void setRemovePrefix(boolean removePrefix) { 
     this.removePrefix = removePrefix; 
    } 

    protected int getMaxFileUploadSize() { 
     return this.intMaxFileUploadSize; 
    } 

    protected void setMaxFileUploadSize(int intMaxFileUploadSizeNew) { 
     this.intMaxFileUploadSize = intMaxFileUploadSizeNew; 
    } 

    private void debug(String ... msg) { 
     for (String m : msg) { 
      //System.out.println("[DEBUG] " + m); 
     } 
    } 
} 

然後,您需要繼承它,並提供端口:


package xxx.xxxx.xxxxx; 

import javax.servlet.ServletConfig; 

public class MyProxyServlet extends ProxyServlet { 
    public void init(ServletConfig servletConfig) { 

     //System.out.println("in the init"); 
     setFollowRedirects(true); 

     setRemovePrefix(false); 
     //setProxyPath("gui/" + getProxyPath()); 
     setProxyPort(8080); 

    } 

}