Annonces
|
|
|
|
 |
||
 |
 |
 |
Le servlet qui va gérer l'ensemble du mécanisme de redirection des ressources Web va être installé sur le serveur. Pour mettre en place ce mécanisme, il faut que le premier lien pointe vers ce servlet. Celui ci devra alors rapatrier la page Web et en modifier l'ensemble des liens avant de l'expédier à l'internaute.
Les liens pointant vers des ressources susceptibles de contenir des liens vers d'autres pages doivent être modifiés pour pointer vers le servlet, tandis que les autres doivent continuer de pointer vers les ressources originelles. Bien entendu, les liens pointant vers le servlet devront également contenir l'ensemble des informations nécessaires pour retrouver la ressource originelle demandée par l'internaute.
Pour pouvoir récupérer les ressources originales, le servlet doit impérativement connaître l'adresse de la page. Celle-ci doit donc être passée en argument au servlet. L'URL de la ressource originelle est donc accolée à la suite de l'URL du servlet. Les adresses pointant vers le servlet seront donc de la forme: <http://adresse-servlet/adresse-ressources>. Soit pour ce projet: <http://pc-grit12:8080/servlet/Projet/adresse-ressource>
La méthode " getPathInfo " permet de récupérer l'argument " /adresse-ressource ". Il faut noter que le " / " est obligatoire pour séparer l'adresse du servlet de celle de la ressource. En effet, Tomcat aurait quelques difficultés à interpréter une adresse du type: <http://pc-grit12:8080/servlet/Projetadresse-ressource> puisque Projetadresse-ressource n'est pas considéré par Tomcat comme étant une ressource valide.
Il existe trois types d'adresses:
Or, pour que le mécanisme de redirection décrit précédemment fonctionne, il est impératif que toutes les URL soient absolues. Dans le cas contraire, les liens seraient interprétés par le navigateur de l'internaute comme étant relatifs au serveur ou à la page en cours. Dans le cas d'une page redirigée, l'adresse de la page en cours ne correspond pas à son adresse réelle mais à la nouvelle adresse, en l'occurrence celle du servlet. Un clic sur un lien relatif entraînerait donc une requête sur le serveur qui ne pourrait de toute façon pas aboutir puisque, pour le servlet, l'adresse de la donnée originelle resterait inconnue.
Ainsi, il faut modifier non seulement les liens qui doivent, par nature, pointer vers le servlet mais également les liens pointant vers des ressources originelles telles que les images.
L'adresse absolue de la page en cours est connue puisque celle-ci a été récupérée. L'adresse relative a également été extraite de la page. Ces deux adresses sont alors décomposées avant d'être scindées pour ne plus en former qu'une seule.
Le programme repère si l'URL relative n'est pas déjà en réalité absolue, si elle ne pointe pas vers une balise située dans la page en cours ou vers une adresse e-mail (mailto:identifiant@domaine.extension). Si c'est le cas, le lien reste inchangé, sinon, il faut continuer l'algorithme.
Il découpe les URL absolues et relatives suivant les caractères " / " qu'elles contiennent. Si le dernier argument de l'URL absolue de la page en cours comporte un point ou est une chaîne vide, il est supprimé.
ex: http://www.exemple.com/dossier/index.html
devient http://exemple.com/dossier
Bien entendu, si l'URL absolue est du type http://www.exemple.com rien ne sera supprimé, même si le nom de domaine comporte un point.
A l'issu de cette étape, le programme retourne des URL absolues et relatives du type:
http://www.exemple.com/dossier
exemple/index.html
Elle s'effectue en partant de la fin c'est à dire en travaillant de droite à gauche. Les différents éléments des URL absolues et relatives étant stockés dans des tableaux. Le programme commence par placer le dernier argument de l'URL relative qu'il fait précéder d'un " / ". Puis il remonte progressivement de l'URL relative à l'URL absolue. Si l'un des arguments de l'URL relative est " .. ", celui-ci, ainsi que l'argument qui le précède, ne seront pas concaténés. Si le premier argument de l'adresse relative est une chaîne vide, le programme lui concatène simplement l'adresse du serveur.
Exemples de reconstitution d'URL:
URL de la page en cours: http://www.exemple.com/repertoire URL relative de la ressource: exemple/index.html resultat=index.html =exemple/index.html =repertoire/exemple/index.html =www.exemple.com/repertoire/exemple/index.html =/www.exemple.com/repertoire/exemple/index.html =//www.exemple.com/repertoire/exemple/index.html =http://www.exemple.com/repertoire/exemple/index.html URL de la page en cours: http://www.exemple.com/repertoire/demo/ URL relative de la ressource: ../exemple/index.html resultat=index.html =exemple/index.html =repertoire/exemple/index.html =www.exemple.com/repertoire/exemple/index.html =/www.exemple.com/repertoire/exemple/index.html =//www.exemple.com/repertoire/exemple/index.html =http://www.exemple.com/repertoire/exemple/index.html URL de la page en cours: http://www.exemple.com/repertoire URL relative de la ressource: /exemple/index.html resultat=index.html =exemple/index.html =/exemple/index.html =www.exemple.com/exemple/index.html =/www.exemple.com/exemple/index.html =//www.exemple.com/exemple/index.html =http://www.exemple.com/exemple/index.html
Une fois reconstituées, les URL absolues des ressources qui ne doivent pas passer par le serveur sont intégrées dans la page. Les autres doivent subir un traitement supplémentaire pour pointer vers le servlet.
Comme cela a été expliqué précédemment, il faut faire précéder l'adresse absolue de la ressource par l'adresse du servlet. L'adresse alors obtenue est du type :
<http://adresse_servlet/http://www.exemple.com/index.html>
Soit :
<http://pc-grit12:8080/servlet/Projet/http://www.exemple.com/index.html>
Mais cette technique ne fonctionnement pas correctement car la méthode getPathInfo(), qui permet de récupérer ce qui suit l'adresse du servlet, empêche de doubler les symboles " / ". L'argument qui est alors récupéré est le suivant :
<http:/www.exemple.com/index.html>
Au lieu de
<http://www.exemple.com/index.html>
L'idée serait alors de doubler le premier " / " de l'argument récupéré, mais il n'en est rien puisque sur certains sites, il existe des URL comportant plusieurs " / ".
La solution consiste donc à encoder les " / " des URL dans les pages HTML qui sont envoyés à l'internaute, puis à les décoder au moment de la requête.
Pour cela, le symbole " %2F " est utilisé pour coder les " / " des URL. Cependant, il faut remplacer au préalable les symboles " % " par le symbole " %25 ". En effet, si le codage de tous les " / " par " %2F " est effectué dans une URL où ce symbole est déjà utilisé, celui-ci sera remplacé par erreur au moment du décodage. En remplaçant tous les symboles " % " par " %25 ", ce problème est évité, pour peu que le codage et le décodage soient effectués dans le bon sens.
C'est l'ordre dans lequel le codage est effectué qui assure la conservation de la donnée originelle.
Exemple : URL originelle <http://www.exemple.com/index.html?m=salut%2FA> URL Transmise <http:%2F%2Fwww.exemple.com%2Fendex.html?m=salut%252FA> URL décodée <http//www.exemple.com/index.html?m=salut%2FA>
Si la précaution d'encoder les pourcentages n'avait pas été prise, des erreurs seraient survenues ; comme ici, où l'URL décodée ne correspond pas à la donnée originale.
URL Transmise <http:%2F%2Fwww.exemple.com%2Fendex.html?m=salut%2FA> URL décodée <http//www.exemple.com/index.html?m=salut/A>
|
||
|
|
|