Quelle est la différence entre les méthodes getRequestURI et getPathInfo dans HttpServletRequest ?

Question

Je suis en train de réaliser un contrôleur frontal simple et très léger. J'ai besoin de faire correspondre les chemins de requête à différents gestionnaires (actions) afin de choisir le bon.

Sur ma machine locale [HttpServletRequest.getPathInfo()](http://download.oracle.com/javaee/5/api/javax/servlet/http/HttpServletRequest.html#getPathInfo()) et [HttpServletRequest.getRequestURI()](http://download.oracle.com/javaee/5/api/javax/servlet/http/HttpServletRequest.html#getRequestURI()) donnent les mêmes résultats. Mais je ne suis pas sûr de ce qu'ils donneront dans l'environnement de production.

Quelle est la différence entre ces méthodes et que dois-je choisir ?

Answer 1

Je vais mettre un petit tableau comparatif ici (juste pour l'avoir quelque part) :

Le servlet est mappé en tant que /test%3F/* et l'application est déployée sous /app .

http://30thh.loc:8480/app/test%3F/a%3F+b;jsessionid=S%3F+ID?p+1=c+d&p+2=e+f#a

Method              URL-Decoded Result           
----------------------------------------------------
getContextPath()        no      /app
getLocalAddr()                  127.0.0.1
getLocalName()                  30thh.loc
getLocalPort()                  8480
getMethod()                     GET
getPathInfo()           yes     /a?+b
getProtocol()                   HTTP/1.1
getQueryString()        no      p+1=c+d&p+2=e+f
getRequestedSessionId() no      S%3F+ID
getRequestURI()         no      /app/test%3F/a%3F+b;jsessionid=S+ID
getRequestURL()         no      http://30thh.loc:8480/app/test%3F/a%3F+b;jsessionid=S+ID
getScheme()                     http
getServerName()                 30thh.loc
getServerPort()                 8480
getServletPath()        yes     /test?
getParameterNames()     yes     [p 2, p 1]
getParameter("p 1")     yes     c d

---

Dans l'exemple ci-dessus, le serveur fonctionne sur le serveur localhost:8480 et le nom 30thh.loc a été mis en OS hosts fichier.

Commentaires

• "+" est traité comme un espace uniquement dans la chaîne de requête

• L'ancre "#a" n'est pas transférée au serveur. Seul le navigateur peut l'utiliser.

• Si le url-pattern dans le mappage du servlet ne se termine pas par * (par exemple /test ou *.jsp ), getPathInfo() retours null .

Si Spring MVC est utilisé

• Méthode getPathInfo() retours null .

• Méthode getServletPath() renvoie la partie entre le chemin d'accès au contexte et l'identifiant de la session. Dans l'exemple ci-dessus, la valeur serait /test?/a?+b

• Soyez prudent avec les parties encodées de l'URL @RequestMapping et @RequestParam au printemps. Il est bogué (version actuelle 3.2.4) et est habituellement ne fonctionne pas comme prévu .

Answer 2

getPathInfo() donne les informations de chemin supplémentaires après l'URI, utilisées pour accéder à votre servlet, alors que getRequestURI() donne l'URI complet.

J'aurais pensé qu'ils seraient différents, étant donné qu'un servlet doit être configuré avec son propre modèle d'URI en premier lieu ; je ne pense pas avoir jamais servi un servlet à partir de Root (/).

Par exemple, si le servlet "Foo" est associé à l'URI "/foo", j'aurais pensé que l'URI :

/foo/path/to/resource

Il en résulterait :

RequestURI = /foo/path/to/resource

et

PathInfo = /path/to/resource

Answer 3

Décomposons l'URL complète qu'un client saisirait dans sa barre d'adresse pour accéder à votre servlet :

http://www.example.com:80/awesome-application/path/to/servlet/path/info?a=1&b=2#boo

Les pièces sont les suivantes

1. Le régime de l'assurance maladie est un régime d'assurance maladie : http
2. nom d'hôte : www.example.com
3. port : 80
4. chemin d'accès au contexte : awesome-application
5. chemin d'accès au servlet : path/to/servlet
6. info sur le chemin : path/info
7. demande : a=1&b=2
8. fragment : boo

L'URI de la demande (renvoyé par [getRequestURI](http://docs.oracle.com/javaee/5/api/javax/servlet/http/HttpServletRequest.html#getRequestURI()) ) correspond aux parties 4, 5 et 6.

(d'ailleurs, même si vous ne le demandez pas, la méthode [getRequestURL](http://docs.oracle.com/javaee/6/api/javax/servlet/http/HttpServletRequest.html#getRequestURL()) vous donnerait les parties 1, 2, 3, 4, 5 et 6).

Aujourd'hui :

• la partie 4 (le chemin d'accès au contexte) est utilisée pour sélectionner votre application particulière parmi les nombreuses autres applications qui peuvent être en cours d'exécution sur le serveur
• la partie 5 (le chemin du servlet) est utilisée pour sélectionner un servlet particulier parmi de nombreux autres servlets qui peuvent être regroupés dans le WAR de votre application.
• la partie 6 (l'information sur le chemin) est interprétée par la logique de votre servlet (par exemple, elle peut pointer vers une ressource contrôlée par votre servlet).
• la partie 7 (la requête) est également mise à la disposition de votre servlet à l'aide de la fonction getQueryString
• la partie 8 (le fragment) n'est même pas envoyée au serveur et n'est pertinente et connue que du client

La règle suivante s'applique toujours (à l'exception des différences d'encodage des URL) :

requestURI = contextPath + servletPath + pathInfo

L'exemple suivant, tiré du Spécification Servlet 3.0 est très utile :

---

Remarque : l'image qui suit, je n'ai pas le temps de la recréer en HTML :

Answer 4

Considérons la conf. de servlet suivante :

   <servlet>
        <servlet-name>NewServlet</servlet-name>
        <servlet-class>NewServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>NewServlet</servlet-name>
        <url-pattern>/NewServlet/*</url-pattern>
    </servlet-mapping>

Maintenant, lorsque je clique sur l'URL http://localhost:8084/JSPTemp1/NewServlet/jhi il invoquera NewServlet car il est mis en correspondance avec le modèle décrit ci-dessus.

Ici :

getRequestURI() =  /JSPTemp1/NewServlet/jhi
getPathInfo() = /jhi

Nous avons ceux-là :

• getPathInfo()

  retours
  une chaîne, décodée par le conteneur web, spécifiant des informations de chemin supplémentaires qui viennent après le chemin du servlet mais avant la chaîne de requête dans l'URL de la demande ; ou null si l'URL n'a pas d'informations de chemin supplémentaires

• getRequestURI()

  retours
  une chaîne contenant la partie de l'URL depuis le nom du protocole jusqu'à la chaîne de requête