1. Introdução ao monitor
1.1. O conceito de ouvinte
Um ouvinte é um objeto usado especialmente para ouvir e processar eventos ou mudanças de estado que ocorrem em outros objetos. Quando ocorre uma situação no objeto monitorado, as ações correspondentes serão tomadas imediatamente. Um ouvinte é na verdade um programa Java comum que implementa uma interface específica. Este programa é usado especificamente para ouvir chamadas de método ou alterações de propriedade de outro objeto Java. Quando o evento acima ocorre no objeto que está sendo ouvido, um determinado método do ouvinte é executado imediatamente.
1.2. Caso do ouvinte-ouvinte ouvindo a janela da janela
pacote me.gacl.listener.demo; importar java.awt.frame; importar java.awt.event.windowEvent; importar java.awt.event.windowlistener; public classe Demo1 { /***Java. A escuta de eventos envolve três componentes: fonte de evento, objeto de eventos, ouvinte de eventos*2. Quando uma ação ocorre na fonte do evento, ele chama um método do ouvinte do evento e passa o objeto de evento ao chamar o método. * Os desenvolvedores podem obter a fonte do evento através do objeto de evento no ouvinte, operando assim na fonte do evento. */ public static void main (string [] args) {quadro f = new Frame (); F.SetSize (400, 400); f.SetVisible (true); //Register event listener f.addWindowListener(new WindowListener(){ public void windowActivated(WindowEvent e) { } public void windowClosed(WindowEvent e) { } /** * When the window form is closed, the WindowListener listener will be heard, * The listener will call the windowClosing method to handle the actions when the window form is closed*/ public void windowClosing(WindowEvent e) { // obtenha o objeto de origem do evento através do objeto Eframe f = (quadro) e.getSource (); windowopened (WindowEvent e) {}}); }}1.3. Projetar um objeto que possa ser ouvido por outros objetos
Quando estamos fazendo desenvolvimento, escrevemos ouvintes para monitorar outros objetos. Então, o que devemos fazer se queremos projetar um objeto para que esse objeto possa ser ouvido por outros objetos? Podemos projetar um objeto de acordo com um modelo rigoroso de processamento de eventos, e esse objeto pode ser ouvido por outros objetos. O modelo de processamento de eventos envolve três componentes: fonte de evento, objeto de eventos e ouvinte de eventos.
Vamos projetar um objeto de pessoa de acordo com o modelo de processamento de eventos. O código específico é o seguinte:
pacote me.gacl.observer;/*** @className: pessoa (fonte de evento)* @Description: projete uma classe de pessoa como fonte de evento. O comportamento dos objetos desta classe (como comer, correr) pode ser ouvido por outros objetos* @Author: Lonely CanGlang* @Date: 2014-9-9 21:26:06 **/ public class Pessoa {/ ** ** ** @field: ouvinte* Defende uma pessoa que você ouve uma variável na classe Pessoa para lembrar o ouvinte. /** * @Method: Eat * @Description: Design Pessoa Comportamento: Eat * @Anthor: The Lone and Rogance * * /public void Eat () {if (ouvinte! fonte*/ ouvinte.doeat (novo evento (this)); }} /*** @Method: Run* @Description: Projetar o comportamento da pessoa: execute* @Anthor: The Lone and Rogance** /public void run () {if (ouvinte! = Null) { /*** Chame o método Dorun do evento para ouvir a classe Pessoa para a classe Run () e passar a ação. * O objeto de evento encapsula a fonte do evento, e isso em novo evento (this) representa a fonte do evento*/ ouvinte.dorun (novo evento (this)); }} / ** * @Method: RegisterListener * @Description: Este método é usado para registrar um ouvinte que ouve o comportamento dos objetos da classe Pessoa * @Anthor: The Douaf Wolf * * @param ouvinte * / public void RegisterListener (ouvinte do PersonListener) {this.listener = ouviso; }}/*** @className: PersonListener (ouvinte de eventos)* @Description: projete a interface do ouvinte para a classe Pessoa (fonte de evento)* @Author: Lonely CanGlang* @Date: 2014-9-9 @MELTOMET: 21:28:06 PM **/interface Person {/** ** USTOMOD: DOAT: * Quando a classe de implementação implementa o método Doeat, você pode monitorar a ação da classe de classe Eat (Eat) * @Anthor: Lonely CanGlang * * @param e */ void Doeat (Evento E); /** * @Method: Dorun * @Description: Este método é usado para ouvir o comportamento do objeto de pessoa executar (executar). * When the implementation class implements the dorun method, you can listen to the action of Person class object run(run)* @Anthor:克克* * @param e */ void dorun(Event e);}/*** @ClassName: Event(event object)* @Description: Design event class to encapsulate event source* @author:克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克� Event(Person source) { this.source = source; } public pessoa getSource () {return fonte; } public void SetSource (fonte da pessoa) {this.source = fonte; }}Após esse design, os objetos da classe Peron podem ser ouvidos por outros objetos. O código de teste é o seguinte:
pacote me.gacl.observer; public class Pessotest { / ** * @Method: main * @Description: Test Pessoa classe * @Anthor: The Arrogant Wolf * * @param args * / public static void main (string [] args) {// pessoa p = nova pessoa (); // Registre o ouvinte que escuta o comportamento de objetos P P.ReGisterListener (new PERSONLISTENER () {// Ouça p Comportamento alimentar public void Doeat (Evento e) {pessoa p = e.getsource (); system.out.out.println (p + "eating");}/ouça -se em execução public dor.out.out.oun (p. System.out.println (p + "comendo"); // p comendo p.eat (); // p em execução p.run (); }}Resultados em execução:
me.gacl.observer.person@4a5ab2 está comendo me.gacl.observer.person@4a5ab2 está executando
2. Ouvintes em Javaweb
2.1. Conceitos básicos
Os ouvintes em Javaweb são uma classe especial definida na especificação do servlet. Eles são usados para ouvir eventos de criação e destruição de objetos de domínio, como ServletContext, HttpSession e ServletRequest em aplicativos da Web, bem como para ouvir eventos nos quais as propriedades nesses objetos de domínio são modificadas.
2.2. Classificação de ouvintes de servlet
Existem vários tipos de ouvintes definidos na especificação do servlet. As fontes de eventos usadas para ouvir são servletContext, httpsession e servletRequest. A especificação do servlet divide vários tipos de ouvintes em três tipos de operações nesses três objetos:
• O ouvinte de eventos que ouve a criação e destruição do próprio objeto de domínio.
• O ouvinte de eventos que ouve para adicionar e excluir propriedades em objetos de domínio.
• Um ouvinte de eventos que ouve o status de um objeto no domínio HTTPSession.
2.3. Ouça a criação e destruição de objetos de domínio de servletContext
A interface ServletContextListener é usada para ouvir os eventos de criação e destruição dos objetos ServletContext. Todas as classes que implementam a interface ServletContextListener podem ouvir a criação e destruição de objetos ServletContext.
• Quando o objeto ServletContext é criado, o método Contextinitialized (ServletContextevent SCET) é disparado.
• Quando o objeto ServletContext é destruído, o método ContextDestroy (ServletContextevent SCET) é ativado.
• Hora de criar e destruir objetos de domínio ServletContext:
Criar: o servidor Startup cria servletContext para cada aplicativo da web
Destruição: Feche o servletContext que representa cada aplicativo da web antes que o servidor seja fechado.
Exemplo: Escreva uma classe MyServletContextListener, implemente a interface ServletContextListener, ouça a criação e destruição de objetos de servletContext
1. Escreva um ouvinte com o seguinte código:
package me.gacl.web.listener;import javax.servlet.ServletContextEvent;import javax.servlet.ServletContextListener;/*** @ClassName: MyServletContextListener* @Description: The MyServletContextListener class implements the ServletContextListener interface, * Therefore, you can listen for the creation and destruction of the Objeto servletContext. * @Author: O orgulhoso lobo* @Date: 2014-9-9 22:26:16 **/ public class MyServletContextListener implementa servletContextListener {@Override public void Contextinitialized (servletContextevent scet) {System.out.println ("ServletConTen; } @Override public void contextDestroyed (servletContextevent scet) {System.out.println ("ServletContext Object Destruction"); }}2. Registre o ouvinte no arquivo web.xml
Mencionamos acima que, para ouvir fontes de eventos, você deve registrar o ouvinte na fonte do evento para monitorar a ação da fonte do evento. Em Javaweb, o registro de escuta é configurado no arquivo web.xml, como segue:
<?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-instance" 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"> <display-name></display-name> <list-list> <lorde-File> Index.jsp </-Welcome-File> </list-List> <!-Registre um ouvinte para ouvir Objetos ServletContext-> <Ilvier> <cription> ServletContextListener Listener </cription> <!-Classe Receiver que implementa a interface ServletContextListener-> <listener-class> me.gacl.web.listener.myServletContextListener </lister-class> </ouvinte> </web-app>
Após essas duas etapas, concluímos a redação e o registro do ouvinte. Quando o servidor da web iniciar, ele registrará automaticamente o ouvinte configurado em web.xml no objeto ServletContext. Dessa forma, o ouvinte desenvolvido MyServletContextListener pode ouvir no objeto ServletContext.
2.4. Ouça a criação e destruição de objetos de domínio HTTPSession
A interface HTTPSessionListener é usada para ouvir a criação e destruição de objetos HTTPSession. Ao criar uma sessão, o método SessionCreated (httpsessionEvent SE) é ativado ao destruir uma sessão e o método SessionDestroy (httpsessionEvent SE) é ativado.
Exemplo: Escreva uma classe MyHttpSessionListener, implemente a interface HTTPSessionListener e ouça a criação e destruição de objetos HTTPSession
1. Escreva um ouvinte com o seguinte código:
package me.gacl.web.listener;import javax.servlet.http.HttpSessionEvent;import javax.servlet.http.HttpSessionListener;/*** @ClassName: MyHttpSessionListener* @Description: The MyHttpSessionListener class implements the HttpSessionListener interface, * Therefore, the two actions of creating and Destruir o objeto HttpSession pode ser ouvido. * @Author: The Lonely CanGlang* @Date: 2014-9-9 23:04:33 **/ public classe myhttpSessionListener implementa httpSessionListener {@Override public void SessionCreated (httpSessionEVent SE) {System.out.println (se.Session; }/* O tempo de destruição da HTTPSession precisa ser configurado em web.xml, da seguinte maneira:* <session-config> </timeout> 1 </session-timeout> </session-CONFIG> essa configuração significa que a sessão é destruída após 1 minuto*/@Override Public Systement Systemer.DestroyEd. }}2. Registre o ouvinte no arquivo web.xml
<!-Registre o ouvinte para ouvir objetos httpssession-> <lister> <cription> httpsessionListener ouvinte </cription> <lister-class> me.gacl.web.listener.myhttpsessionListener </ouvinte-class> </ouvinte> <-configre the the the the ht ht ht ht ht ht ht ht </ouvinte> </ouvinte> <!-configre the the the the ht hts O objeto HttpSession-> <Session-Config> <!-Configure a destruição do objeto httpsession 1 minuto depois-> </timeout> 1 </session-timeout> </session-config>
Quando acessarmos a página JSP, o objeto HTTPSession será criado. Neste momento, podemos observar o processo de criação do objeto HTTPSession no HTTPSessionListener. Podemos escrever uma página JSP para observar o processo de criação do objeto HTTPSession.
Da seguinte forma: index.jsp
< %@ Page Language = "java" import = "java.util. O ID da sessão criada é: $ {pageContext.session.id} </body> </html>Os resultados da operação são os seguintes:
2.5. Ouça a criação e destruição de objetos de domínio servletRequest
Quando a interface servletRequestListener é usada para ouvir a criação e destruição do objeto ServletRequest, o método Requestinitialized (ServletRequestevent SRE) será chamado. Quando o objeto de solicitação é destruído, o método RequestDestroy (ServletRequestevent SRE) do ouvinte será chamado.
ServletRequest Domínio Criação e Destruição Timing:
Criar: Toda vez que o usuário visita, o objeto de solicitação será criado, o objeto de solicitação será destruído: o acesso atual acabou, o objeto de solicitação será destruído.
Exemplo: Escreva uma classe MyServletRequestListener, implemente a interface servletRequestListener, ouça a criação e destruição de objetos servletRequest
1. Escreva um ouvinte com o seguinte código:
package me.gacl.web.listener;import javax.servlet.ServletRequestEvent;import javax.servlet.ServletRequestListener;/*** @ClassName: MyServletRequestListener* @Description: The MyServletRequestListener class implements the ServletRequestListener interface, * Therefore, you can listen for the creation and destruction of the Objeto servletRequest. * @Author: O orgulhoso lobo* @Date: 2014-9-9 23:50:08 **/ classe pública myServletReQuestListener implementa servletRequestListener {@Override public void requestDestroyed (servletRequestEvent sre) {System.out.Println (Sre.GeRSeRreLEd (Sre.GetLeed (SrevOrTled; } @Override public void requestInitialized (servletRequestevent sre) {System.out.println (sre.getServletRequest () + "criado !!"); }}2. Registre o ouvinte no arquivo web.xml
<!-Registre o ouvinte para ouvir o objeto ServletRequest-> <Ilanter> <cription> servletRequestListener ouvinte </cription> <lister-class> me.gacl.web.listener.myServletrequestListener </lister-class> </ouvinte>
Os resultados dos testes são os seguintes:
A partir do resultado da execução, podemos ver que o usuário cria um objeto de solicitação sempre que acessar, e o objeto de solicitação será destruído após a conclusão do acesso.
O exposto acima é uma breve explicação do ouvinte.