4. Filtrage d'une réponse

4.1. Fonctionnement de ce filtrage

Il est également possible de filtrer une réponse à l'aide d'un filtre. Le déroulement des opérations est un peu plus délicat, car on doit dans ce cas fournir une réponse qui n'est pas la vraie réponse à la méthode doFilter(). Effectivement, fournir à cette méthode la vraie réponse pourrait donner la possibilité aux filtres suivants ou à la servlet finale, d'écrire directement dans le buffer de réponse, et de faire appel à sa méthode flush(), ce qui enverrait directement la réponse au navigateur client. On ne pourrait donc plus agir sur le contenu de la réponse. L'idée consiste donc à fournir à la chaîne un buffer que l'on construit nous-mêmes, et dont on peut contrôler l'écriture dans le vrai buffer de réponse. Comme l'objet réponse que l'on doit passer en paramètre de doFilter() est de type ServletResponse, il nous faut construire une implémentation de cette classe. Il ne s'agit bien sûr pas de réécrire l'intégralité de cette classe, juste d'intercepter ce que la servlet pourrait écrire dans le buffer de réponse. Pour cela, on peut surcharger la méthode getWriter() de façon à retourner un PrintWriter sur notre buffer, plutôt que sur le buffer de réponse. Écrivons tout d'abord notre implémentation de ServletResponse.

Exemple 34. Filtrage avec modification de la réponse - 1

 public  class CustomServletResponse  extends HttpServletResponseWrapper {

    // création d'un writer sur un buffer en mémoire
    private Writer writer =  new CharArrayWriter() ;

    public CustomServletResponse(HttpServletResponseWrapper response) {
       super(response) ;
   }

    @Override
    public PrintWriter getWriter() {
       // retourne un PrintWriter sur notre buffer plutôt que sur
       // la vraie réponse
       return  new PrintWriter(writer) ;
   }

    public String toString() {
       return writer.toString() ;
   }
}

Utilisons ensuite cette implémentation en filtrage.

Exemple 35. Filtrage avec modification de la réponse - 2

 public  class PostFilter  implements Filter {

    // méthodes init() et destroy()   
   
    public  void doFilter(ServletRequest request, ServletResponse response,
                        FilterChain filterChain)
    throws IOException, ServletException {

       // construction de notre fausse réponse
      ServletResponse fakeResponse =  new CustomServletResponse(response) ;

       // appel de la servlet   
      filterChain.doFilter(request, response) ;
      
       // récupération de la réponse qu'elle a généré
      String providedResponse = fakeResponse.toString() ;
      
       // on peut modifier cette réponse ici
      String modifiedResponse = ... ;
      
       // puis l'envoyer vers le client
       // on remet les en-têtes HTTP en fonction de ce qui a été fait
      response.setContentLength(modifiedResponse.length()) ;
	  
       // envoi de la réponse modifiée sur le flux de sortie
      PrintWriter printWriter = response.getWriter() ;
      printWriter.write(modifiedResponse) ;
      printWriter.close() ;
   }
}

Cet exemple reste assez basique. Si les méthodes qui interrogent la réponse vont fonctionner correctement, notre implémentation risque fort d'échouer si la servlet filtrée fait un appel à la méthode getOutputStream(), ou aux méthodes setContentType(), setCharacterEncoding(), ou encore sendError(). Il convient donc de le compléter avant de le mettre en production, ou de ne l'utiliser que dans des cas simples et parfaitement maîtrisés.
Java servlet et JSP
Retour au blog Java le soir
Cours & Tutoriaux
Table des matières
Introduction
1. Position de l'API Servlet
2. Présentation
Présentation de Tomcat
1. Un peu d'histoire
2. Organisation des répertoires de Tomcat
2.1. Répertoire bin
2.2. Répertoire conf
2.3. Répertoire lib
2.4. Répertoire log
2.5. Répertoire temp
2.6. Répertoire webapp
2.7. Répertoire work
3. Lancement de Tomcat
3.1. Lancement par défaut
3.2. Accéder à l'administration de Tomcat
3.3. Plusieurs instances de Tomcat
4. Configuration de Tomcat
4.1. Introduction
4.2. Élément Server
4.3. Élément Service
4.4. Élément Connector
4.5. Élément Engine
4.6. Élément Host
4.7. Élément Context
4.8. Élément GlobalNamingResources
4.9. Élément Realm
4.10. Élément Valve
5. Définition et chargement des applications web
5.1. Introduction
5.2. Prise en compte des éléments Context
5.3. Chargement et mise à jour à chaud
6. Utilisation de Tomcat avec Apache
API Servlet
1. Introduction
2. Une première servlet
2.1. Le code
2.2. Création de l'application web
2.3. Déploiement dans Tomcat
3. Concepts, cycle de vie
3.1. Requête
3.2. Réponse
3.3. Session
3.4. Application web
3.5. Contexte d'exécution
3.6. Cycle de vie
3.7. Filtre
4. Présentation générale de l'API
4.1. Introduction
4.2. Interfaces disponibles
5. Notion de servlet
5.1. Interfaces servlet
5.2. Cycle de vie d'une servlet
5.3. Paramètres d'initialisation d'une servlet
6. Notion de requête
6.1. Accès aux paramètres d'une requête
6.2. Accès aux éléments de l'en-tête HTTP
6.3. Accès aux éléments de l'URL
6.4. Accès aux paramètres du client
6.5. Accès aux informations de sécurité
6.6. Accès à la session, au contexte et aux informations d'initialisation
7. Notion de réponse
7.1. Contrôle du buffer de sortie
7.2. Contrôle de la réponse HTTP
8. Notion de session HTTP
9. Redirection ou inclusion d'une ressource
10. Listeners
10.1. Introduction
10.2. Événements de l'API Servlet
10.3. Ajout ou retrait d'un attribut
10.4. Création et destruction d'un contexte
10.5. Notification d'un objet attaché à un contexte
10.6. Déclaration d'un listener dans une application web
11. Connexion à une base
11.1. Introduction
11.2. Connexion manuelle
11.3. Connexion par utilisation de source de données
Filtrage
1. Filtrage de servlets
2. Mise en place d'un filtre
2.1. Écriture d'un filtre
2.2. Déclaration du filtrage
3. Filtrage d'une requête
4. Filtrage d'une réponse
4.1. Fonctionnement de ce filtrage
Java Server Pages
1. Introduction
2. Un premier exemple
2.1. Une première JSP statique
2.2. Une première JSP dynamique
2.3. Fonctionnement interne des JSP
3. JSP scriplet
3.1. Les expressions
3.2. Les déclarations
3.3. Variables prédéfinies
3.4. Scriplet de directives
4. Utilisation de beans
4.1. Introduction
4.2. Déclaration d'un bean existant
4.3. Création d'un nouveau bean
4.4. Utilisation des propriétés d'un bean
5. Inclure un contenu externe dans une JSP
5.1. Introduction
5.2. Inclusion au lancement de l'application
5.3. Inclusion au traitement de la requête
6. Utilisation de bibliothèques de tags
6.1. Introduction
6.2. Bibliothèque core
7. Internationalisation
7.1. Notion de bundle
7.2. Internationalisation de pages JSP
Projet exemple
1. Présentation du projet