Problème avec GWT derrière un proxy inverse - Nginx ou apache

j'ai le même problème, et j'ai ouvert un rapport de bug:

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

le problème est qu'il a été marqué "en tant que Design", donc je ne pense pas qu'il sera corrigé.

j'ai trouvé cette solution pour moi. J'ai étendu la classe RemoteServiceServlet et j'ai forcé GWT à charger le fichier de politique de sérialisation à partir de ContextName au lieu de URL. Puis j'ai étendu mon service à ma classe au lieu de Classe RemoteServiceServlet. De cette façon, l'application sera déverrouillée de l'url d'où elle sera appelée.

voici ma classe personnalisée:

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;
      }
}

Michele,

Merci pour l'exemple de servlet pour gérer ce problème. Cependant, lorsque j'ai essayé d'utiliser votre approche, cela a fonctionné dans l'environnement de proxy inverse mais pas dans mon environnement de mode dev eclipse.

j'ai adopté une approche qui me permettrait de me déplacer sans heurt entre mes environnements dev et prod.

comme vous l'avez fait, J'ai surpassé RemoteServiceServlet mais je n'ai remplacé que les suivants...

@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);
}

dans ma configuration apache ajouter...

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

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

cette approche fonctionne dans tous les scénarios et délègue l'url "mucking" aux paramètres de proxy d'apache qui est l'approche que j'ai toujours adoptée.

les Commentaires sur cette approche sont appréciés

j'ai rencontré un problème similaire, une solution réussie a été de faire en sorte que tous les objets sérialisés implémentent L'interface Isserialisable de GWT (en plus de L'interface sérialisable standard). Si vous lisez le message, il indique qu'une politique de sérialisation compatible avec 1.3.3 sera utilisée - la Politique compatible avec 1.3.3 exige que tous vos objets sérialisés implémentent L'interface Isserialisable, donc en l'ajoutant, tout a fonctionné.

je ne craint que le la Politique d'héritage sera abandonnée dans les versions futures de GWT, donc je suis aussi à la recherche d'une meilleure solution de contournement moi-même.

la réponse de KC est bonne. Pour ceux qui ne veulent pas se faufiler avec apache configs, ou ont besoin d'un moyen rapide et sale de tester, voici une solution de code seulement.

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);
}

L'application est sur http://server/bar, le proxy est de le servir à http://proxy/foo/bar D'où moduleBaseURL = moduleBaseURLHdr.remplacer ("foo / bar", "bar"); rend GWT heureux. De même, si l'application est à http://server/bar et le proxy est en service à http://proxy/, vous devez ajouter la barre au moduleBaseURL (juste avant le paquet nom.) Ceci peut être généralisé par l'utilisation de getServletContext().getContextPath () etc...

mon but était d'éviter les en-têtes supplémentaires qui rendraient le déploiement et la configuration plus difficiles. J'ai résolu ce problème en remplaçant 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);
    }

dans le code ci-dessus:

extractGwtModuleName() extraits de la dernière chaîne préfixée et / ou suivie de slash

joinPaths() joint plusieurs parties d'url, supprime les slashes inutiles

utilisez restful JSON pour vos appels RPC au lieu de GWT-RPC. Cela résout le problème du mandataire inversé puisqu'aucun fichier de sérialisation n'est requis.