1. Surveiller l'introduction
1.1. Le concept d'auditeur
Un auditeur est un objet spécialement utilisé pour écouter et traiter des événements ou des changements d'état qui se produisent sur d'autres objets. Lorsqu'une situation se produit dans l'objet surveillé, les actions correspondantes seront prises immédiatement. Un auditeur est en fait un programme Java ordinaire qui implémente une interface spécifique. Ce programme est spécifiquement utilisé pour écouter les appels de méthode ou les changements de propriété d'un autre objet Java. Lorsque l'événement ci-dessus se produit dans l'objet écouté, une certaine méthode de l'auditeur est exécutée immédiatement.
1.2. Cas de l'auditeur - Évaluer Écoute à la fenêtre de la fenêtre
Package Me.gacl.Listener.demo; Importer java.awt.frame; import java.awt.event.windowEvent; import java.awt.event.windowListener; public class demo1 {/ ** * Java Event Mécanisme d'écoute * 1. L'écoute d'événements implique trois composants: source d'événement, objet d'événement, écouteur d'événement * 2. Lorsqu'une action se produit sur la source de l'événement, il appellera une méthode de l'écouteur d'événements et passera l'objet de l'événement lors de l'appel de la méthode. * Les développeurs peuvent obtenir la source d'événement via l'objet Event dans l'auditeur, opérant ainsi sur la source d'événement. * / public static void main (String [] args) {frame f = new frame (); F.SetSize (400, 400); f.setVisible (true); // Enregistrer l'auditeur des événements F.AddwindowListener (new WindowListener () {public void windowActivated (windowEvent e) {} public void windowclosed (windowevent e) {} / ** * Lorsque le formulaire de fenêtre est fermé, le formulaire de fenêtre de WindowListener sera entendu, * L'écoute appellera la méthode de la fenêtre de la fenêtre pour la méthode des actions lorsque la forme de la fenêtre est fermée * L'objet source d'événement via l'objet de l'événement eframe f = (frame) e.getsource (); e) {}}); }}1.3. Concevoir un objet qui peut être écouté par d'autres objets
Lorsque nous faisons du développement, nous écrivons des auditeurs pour surveiller d'autres objets. Alors, que devons-nous faire si nous voulons concevoir un objet afin que cet objet puisse être écouté par d'autres objets? Nous pouvons concevoir un objet en fonction d'un modèle de traitement d'événements strict, et cet objet peut être écouté par d'autres objets. Le modèle de traitement des événements implique trois composants: source d'événement, objet d'événement et écouteur d'événements.
Concevons un objet de personne selon le modèle de traitement des événements. Le code spécifique est le suivant:
package me.gacl.observer; / *** @classname: personne (source d'événement) * @Description: concevez une classe de personne comme source d'événement. Le comportement des objets de cette classe (comme manger, courir) peut être écouté par d'autres objets * @Author: Lonely CanGlang * @Date: 2014-9-9 9:26:06 PM ** / Public Class Person {/ ** * @field: écouteur * Définissez une personne PersonListener variable dans la classe Classe pour se souvenir de l'auditeur passé * / Persondener auditeur; / ** * @Method: manger * @description: conception du comportement de la personne: manger * @anthor: le seul et l'arrogance * * / public void Eat () {if (auditeur! = Null) {/ ** * Appelez l'action de l'événement de l'événement de l'événement de l'événement. source * / écouteur.Doeat (nouvel événement (this)); }} / ** * @Method: Run * @Description: Conception du comportement de la personne: exécuter * @anthor: le seul et l'arrogance * * / public void run () {if (écouteur! = Null) {/ ** * Appelez la méthode Dorun de l'événement de l'événement de l'événement de la méthode. * L'objet d'événement résume la source d'événement, et ceci dans un nouvel événement (this) représente la source d'événement * / auditeur.dorun (nouvel événement (this)); }} / ** * @Method: RegisterListener * @Description: Cette méthode est utilisée pour enregistrer un écouteur qui écoute le comportement des objets de classe de la personne * @anthor: le loup à lavage * * @param écouteur * / public void registerListener (PersonListener écouteur) {this.Listener = écouteur; }} / *** @className: PersonListener (écouteur d'événements) * @Description: Concevoir l'interface de l'écoute pour la classe de personne (source d'événement) * @Author: Lonely CanGlang * @Date: 2014-9-9 9:28:06 PM ** / Interface PersonListener {/ ** * @Method: Dooat * @DesScription: Cette méthode est utilisée pour surveiller l'action du comportement de la personne de Person. * Lorsque la classe d'implémentation met en œuvre la méthode du DoEat, vous pouvez surveiller l'action de la classe de la classe Object Eat (manger) * @anthor: Lonely CANGLANG * * @param e * / void DoEAT (Event E); / ** * @Method: Dorun * @Description: Cette méthode est utilisée pour écouter le comportement de la personne d'objet Personne (Run). * Lorsque la classe d'implémentation implémente la méthode Dorun, vous pouvez écouter l'action de la classe de personne Run (run) * @anthor: 克克 * * @param e * / void dorun (événement e);} / *** @classname: événement (objet de l'événement) * @description: conception de la classe d'événement pour encapsulent la source d'événement * @Author: 克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克 � event (personne Source) {this.Source = Source; } Person public getsource () {return source; } public void setsource (personne source) {this.source = source; }}Après une telle conception, les objets de la classe Peron peuvent être écoutés par d'autres objets. Le code de test est le suivant:
Package me.gacl.observer; classe publique Persontest {/ ** * @Method: Main * @Description: Test Person class * @anthor: le loup arrogant * * @param args * / public static void main (String [] args) {// personne p = new personne (); // Enregistrer l'auditeur qui écoute le comportement des objets P P. RegisterListener (new PersonListener () {// Écoutez P Eating Behavior Public Void Doeat (Event E) {Person P = E.getsource (); System.out.println (P + "Eating");} // Écoutez P Running Public Void Dorun (événement E) {Person P = E.getSource (); System.out.println (P + "Eating");}}); // P mangeant P.Eat (); // p courant p.run (); }}Résultats en cours:
me.gacl.observer.person@4a5ab2 est à manger.gacl.observer.person@4a5ab2 est en cours d'exécution
2. Écouteurs de Javaweb
2.1. Concepts de base
Les auditeurs de Javaweb sont une classe spéciale définie dans la spécification du servlet. Ils sont utilisés pour écouter les événements de création et de destruction d'objets de domaine tels que ServletContext, HttpSession et ServLetRequest dans les applications Web, ainsi que pour écouter les événements dans lesquels les propriétés de ces objets de domaine sont modifiées.
2.2. Classification des auditeurs de servlet
Il existe plusieurs types d'auditeurs définis dans la spécification du servlet. Les sources d'événements utilisées pour l'écoute sont ServletContext, HTTPSession et ServLetRequest. La spécification du servlet divise plusieurs types d'auditeurs en trois types pour les opérations sur ces trois objets:
• Écouteur d'événements qui écoute la création et la destruction de l'objet de domaine lui-même.
• Écouteur d'événements qui écoute l'ajout et la suppression des propriétés dans les objets de domaine.
• Un auditeur d'événements qui écoute le statut d'un objet dans le domaine HTTPSESSION.
2.3. Écoutez la création et la destruction des objets de domaine ServletContext
L'interface ServletContextListener est utilisée pour écouter les événements de création et de destruction des objets ServletContext. Toutes les classes qui implémentent l'interface ServletContextListener peuvent écouter la création et la destruction des objets ServletContext.
• Lorsque l'objet ServletContext est créé, la méthode contextinitialisée (servletContextevent scet) est tirée.
• Lorsque l'objet ServletContext est détruit, la méthode ContextDestRoyed (ServletContexTevent SCET) est activée.
• Temps pour créer et détruire les objets de domaine ServletContext:
Créer: le démarrage du serveur crée ServletContext pour chaque application Web
Destruction: fermez le servletContext représentant chaque application Web avant la fermeture du serveur.
Exemple: Écrivez une classe MyServletContextListener, implémentez l'interface ServletContextListener, écoutez la création et la destruction des objets ServletContex
1. Écrivez un auditeur avec le code suivant:
Package Me.gacl.web.Listener; Importer Javax.servlet.servletContexTevent; Importer Javax.servlet.servletContextListener; / *** @className: MyServletContextListener * @Description: La classe MyServletContextListener implémente l'objet ServletContell, * Par conséquent, vous pouvez écouter pour la création et la création de l'interface ServeContell. * @Author: The Proud Wolf * @Date: 2014-9-9 10:26:16 PM ** / classe publique MyServletContextListener implémente ServletContextListener {@Override public void contextinitialialialialized (ServletContexTevent scet) {System.out.Println ("ServletContext Object Creation"); } @Override public void contextDestRoyed (servletContexTevent scet) {System.out.println ("ServletContext Object Destruction"); }}2. Enregistrez l'auditeur dans le fichier web.xml
Nous avons mentionné ci-dessus pour écouter les sources d'événements, vous devez enregistrer l'auditeur à la source d'événements pour surveiller l'action de la source d'événement. Dans Javaweb, l'enregistrement d'écoute est configuré dans le fichier web.xml, comme suit:
<? xml version = "1.0" encoding = "utf-8"?> <web-app version = "3.0" xmlns = "http://java.sun.com/xml/ns/javaee" xmlns: xsi = "http://www.w3.org/2001/xmlschema-ristance" xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"> <plawer-name> <Lelcome-File-List> <Deen welcome-File> index.jsp </venke-file> </ welcome-file-list> <! - Enregistrez un écouteur pour écouter les objets ServletContext -> <ouciner> <description> ServletContextListener Écouteur </ Description> <! <écouteur-classe> me.gacl.web.Listener.myservletContextListener </ auteur-class> </diner> </ web -pp>
Après ces deux étapes, nous avons terminé l'écriture et l'enregistrement de l'auditeur. Lorsque le serveur Web démarre, il enregistrera automatiquement l'écouteur configuré dans web.xml vers l'objet ServletContext. De cette façon, l'écouteur développé MyServletContextListener peut écouter sur l'objet ServletContext.
2.4. Écoutez la création et la destruction des objets de domaine HTTPSESSE
L'interface httpSessionListener est utilisée pour écouter la création et la destruction des objets httpSession. Lors de la création d'une session, la méthode SessionCreated (httpSessionEvent SE) est activée lors de la destruction d'une session, et la méthode SessionDestRoyed (HttSessionEvent SE) est activée.
Exemple: Écrivez une classe MyHTTSSessionListener, implémentez l'interface HttScessionListener et écoutez la création et la destruction des objets httpSession
1. Écrivez un auditeur avec le code suivant:
Package me.gacl.web.Listener; Importer Javax.servlet.http.httpSessionEvent; Importer Javax.servlet.http.httSessionListener; / *** @className: MyHttSessionListEner * @Description: La classe MyHttpSession de la création de l'interface HTTPSessionListener L'objet httpSession peut être écouté. * @Author: The Lonely CanGlang * @Date: 2014-9-9 11:04:33 PM ** / classe publique MyHTTSSessionListener implémente httpSessionListener {@Override public void sessionCreated (httpSessionEvent se) {System.out.println (se.getSession () + "Created !!"); } / * Le temps de destruction de la HTTPSession doit être configuré dans web.xml, comme suit: * <Session-Config> <Session-Timeout> 1 </ Session-Timeout> </Session-Config> Cette configuration signifie que la session est détruite après 1 minute * / @Override Public Void SessionDestRoyed (HTTSSESSESSEVETEVET; }}2. Enregistrez l'auditeur dans le fichier web.xml
<! - Enregistrer l'auditeur pour écouter les objets httpSession -> <ouvoir> <description> httpSessionListener auditeur </, description> <auditeur-class> me.gacl.web.Listener.myhttpSessionListener </ auteur-class> </ auditeur> <! - Configurez le temps de détruire l'objet httession -> <session-ceron> <! Objet httpSession -> <session-config> <! - Configurez la destruction de l'objet httpSession 1 minute plus tard-> <session-timeout> 1 </ession-timeout> </ession-config>
Lorsque nous accéderons à la page JSP, l'objet HTTPSESSIE sera créé. À l'heure actuelle, nous pouvons observer le processus de création de l'objet httpSession dans le httpSessionListener. Nous pouvons écrire une page JSP pour observer le processus de création de l'objet httpSession.
Comme suit: index.jsp
<% @ Page Language = "Java" Import = "Java.util. *" Pageencoding = "UTF-8"%> <! DocType Html> <Html> <A-Head> <Titre> HttSSessionListener écoute la création de l'objet HTTPSESSSION </Titre> </Ead> <Body> Une fois que vous accédez à la page JSP, HTTPSESSIE </TITME> </EAD> <Body> Une fois que vous accédez à la page JSP, HTTPSESSIE est créée. L'ID de la session créée est: $ {PageContext.Session.id} </body> </html>Les résultats de l'opération sont les suivants:
2.5. Écoutez la création et la destruction des objets de domaine ServletRequest
Lorsque l'interface servletRequestListener est utilisée pour écouter la création et la destruction de l'objet ServLetRequest, la méthode de demandeInitialialized (servletRequestEvent SRE) de l'auditeur sera appelée. Lorsque l'objet de demande est détruit, la méthode de requestRestRoyed (servletRequestEvent SRE) de l'auditeur sera appelée.
ServletRequest Domain Object Creation and Destruction Timing:
CREATE: Chaque fois que l'utilisateur visite, l'objet de demande sera créé, l'objet de demande sera détruit: l'accès actuel est terminé, l'objet de demande sera détruit.
Exemple: Écrivez une classe MyServletRequestListener, implémentez l'interface servletRequestListener, écoutez la création et la destruction d'objets ServLetRequest
1. Écrivez un auditeur avec le code suivant:
Package me.gacl.web.Listener; import javax.servlet.servletRequestEvent; import javax.servlet.servletRequestListener; / *** @className: MyServletRequestListener * @Description: The MyServletRequestListener Class Implongs the ServeRequestLester Interface, * Do objet. * @Author: The Proud Wolf * @Date: 2014-9-9 11:50:08 PM ** / classe publique MyServletRequestListener implémente ServletRequestListener {@Override public Void requestDestROyed (ServletRequestEvent Sre) {System.out.Println (sre.getServerquest () + "Destried !!"); } @Override public void requestInitialized (servLetRequestEvent sre) {System.out.println (sre.getServletRequest () + "Created !!"); }}2. Enregistrez l'auditeur dans le fichier web.xml
<! - Enregistrez l'auditeur pour écouter l'objet ServLetRequest -> <ouvoir> <description> ServletRequestListener auditeur </ Description> <auditeur-classe> me.gacl.web.Listener.myserservletRequestListener </ auteur-class> </diner>
Les résultats des tests sont les suivants:
D'après le résultat d'exécution, nous pouvons voir que l'utilisateur crée un objet de demande à chaque fois qu'il accède et que l'objet de demande sera détruit une fois l'accès terminé.
Ce qui précède est une brève explication de l'auditeur.