1. Introducción del monitor
1.1. El concepto de oyente
Un oyente es un objeto especialmente utilizado para escuchar y procesar eventos o cambios en el estado que ocurren en otros objetos. Cuando se produce una situación en el objeto monitoreado, las acciones correspondientes se tomarán de inmediato. Un oyente es en realidad un programa Java ordinario que implementa una interfaz específica. Este programa se usa específicamente para escuchar llamadas de método o cambios de propiedad de otro objeto Java. Cuando se produce el evento anterior en el objeto que se escucha, un cierto método del oyente se ejecuta de inmediato.
1.2. Caso del oyente-Evento oyente Escuchar la ventana de la ventana
paquete me.gacl.listener.demo; import java.awt.frame; import java.awt.event.windowevent; import java.awt.event.windowlistener; clase pública Demo1 { /***Java Event Listening Mechanismo*1. La escucha de eventos implica tres componentes: fuente de eventos, objeto de evento, oyente de eventos*2. Cuando se produce una acción en la fuente del evento, llamará a un método del oyente del evento y pasará el objeto de evento al llamar al método. * Los desarrolladores pueden obtener la fuente del evento a través del objeto de evento en el oyente, operando así en la fuente del evento. */ public static void main (string [] args) {marco f = new Frame (); F.SetSize (400, 400); F.SetVisible (verdadero); // Registre el oyente de eventos f.addwindowlistener (new WindowsListener () {public void WindowActivated (WindowsEvent e) {} public void WindowClosed (WindowsEvent e) {}/*** Cuando el formulario de ventana está cerrado, se escuchará el oyente de WindowListener,* el escucha del oyente de Windowin. // Obtener el objeto de origen de eventos a través del objeto EFRAME DE ENVÍO = (Frame) E.GetSource (); Windowopened (WindowEvent E) {}}); }}1.3. Diseñe un objeto que pueda ser escuchado por otros objetos
Cuando estamos haciendo desarrollo, escribimos oyentes para monitorear otros objetos. Entonces, ¿qué debemos hacer si queremos diseñar un objeto para que este objeto pueda ser escuchado por otros objetos? Podemos diseñar un objeto de acuerdo con un modelo de procesamiento de eventos estrictos, y este objeto puede ser escuchado por otros objetos. El modelo de procesamiento de eventos involucra tres componentes: fuente de eventos, objeto de eventos y oyente de eventos.
Diseñemos un objeto de persona según el modelo de procesamiento de eventos. El código específico es el siguiente:
paquete me.gacl.observer;/*** @classname: persona (fuente de eventos)* @Description: diseñe una clase de persona como fuente de evento. El comportamiento de los objetos de esta clase (como comer, ejecutar) puede ser escuchado por otros objetos* @author: lonely canglang* @date: 2014-9-9 9:26:06 pm **/ clase pública persona {/ *** @field: oyente* Definir una variable de lista de personas en la clase de persona para recordar el oyente de la persona de la lista de personas pasadas*/ privado persona de la lista de personas; /** * @method: Eat * @Description: Comportamiento de la persona de diseño: Eat * @anthor: la sola y la arrogancia * * /public void eat () {if (oyente! = Null) { /** * Llame al método del oyente Doat para escuchar la acción de objeto de clase de persona (eat), aprobando el objeto de eventos al método de doat, * El objeto de eventos encapsula el evento de eventos, y esto en el evento de Evento (Eat) representa el evento de evento (este). fuente*/ oyente.doeat (nuevo evento (este)); }} /*** @method: run* @Description: el comportamiento de la persona de diseño: run* @anthor: el solitario y la arrogancia** /public void run () {if (oyente! = Null) { /*** Llame al método dorun del oyente para escuchar la acción de clase de persona (ejecutar (ejecutar) Acción, y pasar el evento de eventos de eventos en el método Doeat. * El objeto de evento encapsula la fuente del evento, y esto en el nuevo evento (este) representa la fuente del evento*/ oyente.dorun (nuevo evento (este)); }} / ** * @method: registreListener * @Description: este método se utiliza para registrar un oyente que escucha el comportamiento de los objetos de clase de persona * @anthor: el wolf ausente * * @param oyente * / public void registratListener (persona de personal oyente) {this.listener = oyente; }}/*** @classname: PersonListener (Event Listener)* @Description: Diseñe la interfaz del oyente para la clase Person (fuente de eventos)* @Author: Lonely CANGLANG* @DATE: 2014-9-9 9:28:06 PM **/Interface PersonListener {/*** @method: doeat* @Description: este método se usa a la acción de comportamiento de la acción de la persona. * Cuando la clase de implementación implementa el método doeat, puede monitorear la acción del objeto de clase de persona comer (comer) * @anthor: lonely canglang * * @param e */ void doeat (evento e); /** * @method: dorun * @Description: este método se utiliza para escuchar el comportamiento del objeto de persona ejecutar (ejecutar). * Cuando la clase de implementación implementa el método dorun, puede escuchar la acción de la clase de persona objeto run (run)* @anthor: 克克** @param e*/ void dorun (event e);}/ *** @classname: event (objeto de evento)* @Description: clase de evento para encapsular la fuente* @author: 克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克 � � Event (persona fuente) {this.source class de evento para encapsular* @author: 克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克 � � � � Event (persona fuente) {this. } Pública persona getSource () {Fuente de retorno; } public void setSource (fuente de persona) {this.source = fuente; }}Después de este diseño, otros objetos pueden escuchar objetos de la clase Perón. El código de prueba es el siguiente:
paquete me.gacl.observer; public class Persontest { / ** * @method: main * @Description: Test Person Class * @anthor: The Arrogant Wolf * * @param args * / public static void main (string [] args) {// persona p = nueva persona (); // Registre el oyente que escucha el comportamiento de los objetos p objetos P P.registerListener (new PersonListener () {// Escuchar P Comportamiento alimentario Public Void Doeat (Event E) {Person P = E. E.GetSource (); System.out.println (p + "comer");} // Escuchar a Public Void Dorun (Event E) {Person P = E.getSource (); System.out.println (p + "comer"); // p comiendo p.eat (); // p corriendo p.run (); }}Resultados de ejecución:
me.gacl.observer.person@4a5ab2 se está comiendo me.gacl.observer.person@4a5ab2 se está funcionando
2. Oyentes en Javaweb
2.1. Conceptos básicos
Los oyentes en Javaweb son una clase especial definida en la especificación de servlet. Se utilizan para escuchar eventos de creación y destrucción de objetos de dominio como ServletContext, Httpsession y ServLetRequest en aplicaciones web, así como para escuchar eventos en los que se modifican las propiedades en estos objetos de dominio.
2.2. Clasificación de los oyentes de servlet
Hay múltiples tipos de oyentes definidos en la especificación de servlet. Las fuentes de eventos utilizadas para escuchar son ServletContext, Httpsession y ServLetRequest. La especificación de servlet divide múltiples tipos de oyentes en tres tipos para operaciones en estos tres objetos:
• Oyente de eventos que escucha la creación y destrucción del objeto de dominio en sí.
• Oyente de eventos que escucha para agregar y eliminar propiedades en objetos de dominio.
• Un oyente de eventos que escucha el estado de un objeto en el dominio de httpsession.
2.3. Escuche la creación y destrucción de los objetos de dominio de ServletContext
La interfaz ServletContextListener se utiliza para escuchar los eventos de creación y destrucción de los objetos de servicio de servicio. Todas las clases que implementan la interfaz ServletContextListener pueden escuchar la creación y destrucción de los objetos ServletContext.
• Cuando se crea el objeto ServletContext, se dispara contextinitialized (servletContextEvent scet).
• Cuando se destruye el objeto ServletContext, se activa el método contextDestrOyed (servletContextEvent scet).
• Tiempo para crear y destruir objetos de dominio de ServletContext:
Crear: el inicio del servidor crea servletContext para cada aplicación web
Destrucción: cierre el servletContext que representa cada aplicación web antes de que el servidor esté cerrado.
Ejemplo: escriba una clase myServletContextListener, implementa la interfaz ServletContextListener, escucha la creación y destrucción de los objetos ServletContext
1. Escribe un oyente con el siguiente código:
paquete me.gacl.web.listener; import javax.servlet.servletContextEvent; import javax.servlet.servletContextListener;/*** @classname: myServletContextListener* @Description: la creación de MyServletContextExtener implementa el servletcontextener,*, por lo tanto, puede escuchar la instancia de la creación de la creación de la clase de creation y la escucha de la creación de la creación de la creación de la creación de la creación de la creación. Objeto ServletContext. * @Author: The Proud Wolf* @Date: 2014-9-9 10:26:16 pm **/ clase pública myServletContextListener implementa servletContextListener {@Override public void contextialized (servletcontextevent scet) {System.println ("servletcontext creation"); } @Override public void contextDestroyed (servletContextEvent scet) {System.out.println ("ServletContext Object Destruction"); }}2. Registre al oyente en el archivo web.xml
Mencionamos anteriormente que para escuchar las fuentes de eventos, debe registrar el oyente a la fuente del evento para monitorear la acción de la fuente del evento. En Javaweb, el registro de escucha se configura en el archivo web.xml, de la siguiente manera:
<? xml versión = "1.0" encoding = "utf-8"?> <web-app versión = "3.0" xmlns = "http://java.sun.com/xml/ns/javaee" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaeee/web-app_3_0.xsd"> <wloss <Devene-File-List> <Devene-File> Index.jsp </Welcome-File> </leadde-file-list> <!-Registre a un oyente para escuchar a los objetos de ServletContext-> <Oyeer> <Scoltion> ServletContextListener oyente </soldge> <!-Clase del receptor que implementa la interfaz ServletContextListener->>>>>>> <Oyerer-class> me.gacl.web.listener.myservletContextListener </searer-class> </oyinger> </seb-app>
Después de estos dos pasos, hemos completado la escritura y el registro del oyente. Cuando se inicia el servidor web, registrará automáticamente el oyente configurado en Web.xml al objeto ServletContext. De esta manera, el oyente MyServletContextener desarrollado puede escuchar en el objeto ServletContext.
2.4. Escuche la creación y destrucción de los objetos del dominio de httpsession
La interfaz httpsessionListener se usa para escuchar la creación y destrucción de los objetos de httpsession. Al crear una sesión, el método de session creado (httpsessionEvent se) se activa al destruir una sesión, y el método de sessionDestrOyed (httpsessionevent se) se activa.
Ejemplo: escriba una clase myhttpsessionListener, implementa la interfaz httpsessionListener y escucha la creación y destrucción de los objetos de httpsession
1. Escribe un oyente con el siguiente código:
paquete me.gacl.web.listener; import javax.servlet.http.httpsessionEvent; import javax.servlet.http.httpsessionListener;/*** @className: myHttpsessionListener* @Description: The MyHttPsessionListener classsssion de la clase Httpsession Se puede escuchar destruir el objeto de httpsession. * @Author: The Lonely CANGLANG* @Date: 2014-9-9 11:04:33 pm **/ clase pública myHttPsessionListener implementa httpsessionListener {@Override public void sessionCreated (httpSessionEvent se) {system.out.println (se.getsession () + "creado!"); "); }/* El tiempo de destrucción de httpsession debe configurarse en web.xml, como sigue:* <session-config> <session timeOut> 1 </session timeOut> </session-config> Esta configuración significa que la sesión está destruida después de 1 minuto*/@Override public void droyeded (httpsessionsioneVentE) {System.out. }}2. Registre al oyente en el archivo web.xml
< Objeto httpsession-> <session-config> <!-Configure la destrucción del objeto httpsession después de 1 minuto del objeto httpsession-> <siseTimeout> 1 </session timeOut> </session-config>
Cuando accedemos a la página JSP, se creará el objeto Httpsession. En este momento, podemos observar el proceso de creación del objeto Httpsession en el httpsessionListener. Podemos escribir una página JSP para observar el proceso de creación del objeto httpsession.
Como sigue: index.jsp
< %@ page lenguaje = "java" import = "java.util.*" PageEncoding = "UTF-8" %> <! DocType Html> <html> <foad> <title> httpsessionListener oyente escucha en la creación del objeto deression https </title> </head> <body> una vez que accede a la página JSPE, httpsession se crea. La identificación de la sesión creada es: $ {pageContext.session.id} </body> </html>Los resultados de la operación son los siguientes:
2.5. Escuche la creación y destrucción de los objetos de dominio de ServletRequest
Cuando la interfaz ServLetRequestListener se utiliza para escuchar la creación y destrucción del objeto ServLetRequest, se llamará al método Solicializado (ServLetRequestEvent SRE) del oyente. Cuando se destruye el objeto de solicitud, se llamará al método Solicitar Destruyado (ServLetRequestEvent SRE) del oyente.
ServLetRequest Dominio de dominio de la creación y la destrucción de objetos:
Crear: Cada vez que el usuario visita, se creará el objeto de solicitud, el objeto de solicitud será destruido: el acceso actual ha terminado, el objeto de solicitud se destruirá.
Ejemplo: escriba una clase myServletRequestListener, implementa la interfaz ServLetRequestListener, escucha la creación y destrucción de los objetos ServLetRequest
1. Escribe un oyente con el siguiente código:
paquete me.gacl.web.listener; import javax.servlet.servletRequestEvent; import javax.servlet.servletRequestListener;/*** @classname: myServletRequestListener* @Description: la creación de MyServletRequestener implementa el servletRequestener,*, por lo tanto, puede escuchar la creación de la creación de la creación de la creación de la creación de la creación de la creación de la creación de la creación de la creación de la creación de la creación de la creación. ServLetRequest Object. * @Author: El orgulloso Wolf* @Date: 2014-9-9 11:50:08 PM **/ clase pública myServletRequestListener implementa ServLetRequestListener {@Override public void requestDestroyed (ServLetRequestEvent SRE) {System.out.println (sre.getServletRequest () +); } @Override public void requestInitialized (ServLetRequestEvent sre) {System.out.println (sre.getServletRequest () + "creado !!"); }}2. Registre al oyente en el archivo web.xml
<
Los resultados de la prueba son los siguientes:
Desde el resultado de la ejecución, podemos ver que el usuario crea un objeto de solicitud cada vez que acceda, y el objeto de solicitud se destruirá después de completar el acceso.
Lo anterior es una breve explicación del oyente.