反向代理后面的 GWT 问题 - nginx 或 apache

Question

当 GWT 在反向代理后面时，我遇到了这个问题。后端应用程序部署在上下文中 - 我们称之为 /context。

当我直接点击时，GWT 应用程序工作正常：

http://host:8080/context/

我可以配置它前面有一个反向代理。这是我的 nginx 示例：

upstream backend {
    server 127.0.0.1:8080;
}

...

location / {
   proxy_pass        http://backend/context/;
}

但是，当我运行反向代理时，GWT 感到困惑，说：

2009-10-04 14:05:41.140:/:WARN:  Login: ERROR: The serialization policy file '/C7F5ECA5E3C10B453290DE47D3BE0F0E.gwt.rpc' was not found; did you forget to include it in this deployment?
2009-10-04 14:05:41.140:/:WARN:  Login: WARNING: Failed to get the SerializationPolicy 'C7F5ECA5E3C10B453290DE47D3BE0F0E' for module 'https://hostname:444/'; a legacy, 1.3.3 compatible, serialization policy will be used.  You may experience SerializationExceptions as a result.
2009-10-04 14:05:41.292:/:WARN:  StoryService: ERROR: The serialization policy file '/0445C2D48AEF2FB8CB70C4D4A7849D88.gwt.rpc' was not found; did you forget to include it in this deployment?
2009-10-04 14:05:41.292:/:WARN:  StoryService: WARNING: Failed to get the SerializationPolicy '0445C2D48AEF2FB8CB70C4D4A7849D88' for module 'https://hostname:444/'; a legacy, 1.3.3 compatible, serialization policy will be used.  You may experience SerializationExceptions as a result.

换句话说，GWT 没有得到需要在 /context/ 前面添加的单词，然后寻找 C7F5ECA5E3C10B453290DE47D3BE0F0E.gwt.rpc，但是仅当请求通过代理时。解决方法是将上下文添加到网站的 url：

location /context/ {
    proxy_pass        http://backend/context/;
}

但这意味着上下文现在是用户看到的 url 的一部分，这很丑陋。

有人知道在这种情况下如何让 GWT 高兴吗？

软件版本：
GWT - 1.7.0（与 1.7.1 相同的问题）
Jetty - 6.1.21（但在tomcat下也存在同样的问题）
nginx - 0.7.62（apache 2.x 下有同样的问题）

我使用 DonsProxy，但那里没有什么值得注意的。

Answer 1

我遇到了同样的问题，我打开了错误报告：

http://code.google.com/p/google-web-toolkit/issues/detail?id=4817

问题是它被标记为“作为设计”，所以我认为它不会固定的。

我为我找到了这个解决方案。我扩展了 RemoteServiceServlet 类，并强制 GWT 从 ContextName 而不是 URL 开始加载序列化策略文件。
然后我扩展了我的服务类而不是 RemoteServiceServlet 类。
通过这种方式，应用程序将与调用它的 url 取消链接。

这是我的自定义类：

import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.ParseException;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;
import com.google.gwt.user.server.rpc.SerializationPolicy;
import com.google.gwt.user.server.rpc.SerializationPolicyLoader;

public class MyRemoteServiceServlet extends RemoteServiceServlet
{
    @Override
    protected SerializationPolicy doGetSerializationPolicy(HttpServletRequest request, String moduleBaseURL, String strongName)
    {
        return MyRemoteServiceServlet.loadSerializationPolicy(this, request, moduleBaseURL, strongName);
    }


    /**
      * Used by HybridServiceServlet.
      */
      static SerializationPolicy loadSerializationPolicy(HttpServlet servlet,
      HttpServletRequest request, String moduleBaseURL, String strongName) {
    // The serialization policy path depends only by contraxt path
    String contextPath = request.getContextPath();

    SerializationPolicy serializationPolicy = null;


    String contextRelativePath = contextPath + "/";



      String serializationPolicyFilePath = SerializationPolicyLoader.getSerializationPolicyFileName(contextRelativePath
          + strongName);

      // Open the RPC resource file and read its contents.
      InputStream is = servlet.getServletContext().getResourceAsStream(
          serializationPolicyFilePath);
      try {
        if (is != null) {
          try {
        serializationPolicy = SerializationPolicyLoader.loadFromStream(is,
            null);
          } catch (ParseException e) {
        servlet.log("ERROR: Failed to parse the policy file '"
            + serializationPolicyFilePath + "'", e);
          } catch (IOException e) {
        servlet.log("ERROR: Could not read the policy file '"
            + serializationPolicyFilePath + "'", e);
          }
        } else {
          String message = "ERROR: The serialization policy file '"
          + serializationPolicyFilePath
          + "' was not found; did you forget to include it in this deployment?";
          servlet.log(message);
        }
      } finally {
        if (is != null) {
          try {
        is.close();
          } catch (IOException e) {
        // Ignore this error
          }
        }
      }

    return serializationPolicy;
      }
}

Answer 2

Michele，

谢谢您提供的示例 servlet 来处理这个问题。然而，当我尝试使用你的方法时，它在反向代理环境中工作，但在我的开发模式 Eclipse 环境中不起作用。

我采取了一种方法，可以让我在开发和生产环境之间无缝切换。

正如你所做的那样，我覆盖了 RemoteServiceServlet 但我只替换了以下内容...

@Override
protected SerializationPolicy doGetSerializationPolicy(
        HttpServletRequest request, String moduleBaseURL, String strongName) {
    //get the base url from the header instead of the body this way 
    //apache reverse proxy with rewrite on the header can work
    String moduleBaseURLHdr = request.getHeader("X-GWT-Module-Base");

    if(moduleBaseURLHdr != null){
        moduleBaseURL = moduleBaseURLHdr;
    }

    return super.doGetSerializationPolicy(request, moduleBaseURL, strongName);
}

在我的 apache 配置中我添加了...

ProxyPass /app/ ajp://localhost:8009/App-0.0.1-SNAPSHOT/

RequestHeader edit X-GWT-Module-Base ^(.*)/app/(.*)$ $1/App-0.0.1-SNAPSHOT/$2

这种方法适用于所有场景，并将 url“清理”委托给 apache 的代理设置，这是我一直采用的方法。

感谢对这种方法的评论

Answer 3

我相当确定这里的正确答案是修补源代码并提交错误报告。另一种选择是在后端的 / 处运行 GWT 应用程序。

我更喜欢前者，但后者也应该有效。如果您确实需要将事物分离到多个上下文中，请使用不同的端口号？

Answer 4

我遇到了类似的问题，一个成功的解决方法是让所有序列化对象实现 GWT 的 IsSerializable 接口（除了标准 Serialized 接口之外）。如果您阅读该消息，它指出“将使用旧的、1.3.3 兼容的序列化策略” - 1.3.3 兼容策略要求所有序列化对象实现 IsSerialized 接口，因此通过添加它，一切正常。

我确实担心 GWT 的未来版本将不再支持遗留策略，因此我自己也在寻找更好的解决方法。

Answer 5

KC的回答很好。对于那些不想乱搞 apache 配置，或者需要一种快速而肮脏的方法来测试的人，这里有一个仅代码的解决方案。

protected SerializationPolicy doGetSerializationPolicy(final HttpServletRequest request, String moduleBaseURL, final String strongName) {
    final String moduleBaseURLHdr = request.getHeader("X-GWT-Module-Base");
    if (moduleBaseURLHdr != null) {
        moduleBaseURL = moduleBaseURLHdr.replace("foo/bar", "bar");
    }
    return super.doGetSerializationPolicy(request, moduleBaseURL, strongName);
}

应用程序位于 http://server/bar 上，代理在 http://proxy/foo/bar 上为其提供服务
因此 moduleBaseURL = moduleBaseURLHdr.replace("foo/bar", "bar");让 GWT 开心。
同样，如果应用程序位于 http://server/bar 并且代理在 http://proxy/ 上提供服务，则需要将 bar 添加到 moduleBaseURL（右在包名称之前）。
这可以通过使用 getServletContext().getContextPath() 等来概括......

Answer 6

我的目标是避免额外的标头，这会使部署和配置变得更加困难。我通过覆盖 RemoteServiceServlet.doGetSerializationPolicy() 解决了这个问题：

   @Override
    protected SerializationPolicy doGetSerializationPolicy(HttpServletRequest request, String moduleBaseURL, String strongName) {
        String localServerAddress = "http://127.0.0.1:" + getThreadLocalRequest().getLocalPort();
        String localContextPath = getServletConfig().getServletContext().getContextPath();
        String moduleName = extractGwtModuleName(moduleBaseURL); 
        String localModuleBaseURL = joinPaths(localServerAddress, localContextPath, moduleName, "/"); 
        return super.doGetSerializationPolicy(request, localModuleBaseURL, strongName);
    }

在上面的代码中：
extractGwtModuleName() 提取前缀和/或后跟斜杠的最后一个字符串
joinPaths() 连接多个 url 部分，删除不必要的斜杠

Answer 7

使用 Restful JSON 进行 RPC 调用，而不是 GWT-RPC。
这解决了反向代理问题，因为不需要序列化文件。