1. Monitor Pendahuluan
1.1. Konsep pendengar
Seorang pendengar adalah objek yang secara khusus digunakan untuk mendengarkan dan memproses peristiwa atau menyatakan perubahan yang terjadi pada objek lain. Ketika suatu situasi terjadi pada objek yang dipantau, tindakan yang sesuai akan segera diambil. Seorang pendengar sebenarnya adalah program Java biasa yang mengimplementasikan antarmuka tertentu. Program ini secara khusus digunakan untuk mendengarkan panggilan metode atau perubahan properti dari objek Java lain. Ketika peristiwa di atas terjadi pada objek yang didengarkan, metode tertentu dari pendengar segera dieksekusi.
1.2. Kasus pendengar-Bahkan pendengar mendengarkan jendela jendela
Paket Me.Gacl.Listener.demo; import java.awt.frame; import java.awt.event.windowevent; impor java.awt.event.windowlistener; kelas publik demo1 { /***mekanisme mendengarkan acara java*1. Mendengarkan acara melibatkan tiga komponen: sumber acara, objek acara, pendengar acara*2. Ketika suatu tindakan terjadi pada sumber acara, itu akan memanggil metode pendengar acara dan meneruskan objek acara saat memanggil metode. * Pengembang dapat memperoleh sumber acara melalui objek acara di pendengar, sehingga beroperasi di sumber acara. */ public static void main (string [] args) {frame 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) { // Dapatkan Objek Sumber Acara Melalui Objek Acara Eframe F = (Frame) E.GetSource (); windowopened (windowevent e) {}}); }}1.3. Rancang objek yang dapat didengarkan oleh objek lain
Ketika kami melakukan pengembangan, kami menulis pendengar untuk memantau objek lain. Jadi apa yang harus kita lakukan jika kita ingin merancang objek sehingga objek ini dapat didengarkan oleh objek lain? Kami dapat merancang objek sesuai dengan model pemrosesan acara yang ketat, dan objek ini dapat didengarkan oleh objek lain. Model pemrosesan acara melibatkan tiga komponen: sumber acara, objek acara, dan pendengar acara.
Mari kita rancang objek seseorang sesuai dengan model pemrosesan acara. Kode spesifiknya adalah sebagai berikut:
Paket me.gacl.observer;/*** @classname: orang (sumber acara)* @description: Desain kelas orang sebagai sumber acara. Perilaku objek kelas ini (seperti makan, berlari) dapat didengarkan oleh objek lain* @Author: Lonely CanGang* @Date: 2014-9-9 9:26:06 PM **/ orang kelas publik {/ *** @Field: pendengar* Tentukan orang yang mendengarkan orang di kelas yang dilewati* dengan pendengar yang dilewati*. /** * @Method: eat * @Description: Design Person's behavior: eat * @Anthor: The lone and arrogance* */ public void eat() { if (listener != null) { /** * Call the listener's doeat method to listen to the Person class object eat(eat) action, passing the event object to the doeat method, * The event object encapsulates the event source, and this in new Event(this) represents the event Sumber*/ listener.doeat (acara baru (ini)); }} /*** @method: Jalankan* @description: perilaku orang desain: Jalankan* @anthor: The Lone and Arogance** /public void run () {if (pendengar! = Null) { /*** Hubungi metode Dorun dari Metode Doeat untuk mendengarkan aksi Objek Kelas Orang. * Objek acara merangkum sumber acara, dan ini di acara baru (ini) mewakili sumber acara*/ listener.dorun (acara baru (ini)); }} / ** * @method: RegisterListener * @description: Metode ini digunakan untuk mendaftarkan pendengar yang mendengarkan perilaku objek kelas orang * @anthor: The Aloof Wolf * * @param listener * / Public void registerListener (personlistener listener) {this.listener = pendengar; }}/*** @ClassName: personListener (pendengar acara)* @description: Desain antarmuka pendengar untuk kelas orang (sumber acara)* @Author: Lonely canGang* @Date: 2014-9-9 9:28: et-et. * Ketika kelas implementasi mengimplementasikan metode DOEAT, Anda dapat memantau tindakan orang kelas orang Eat (Eat) * @anthor: Lonely CanGang * * @param e */ void doeat (peristiwa e); /** * @method: dorun * @description: Metode ini digunakan untuk mendengarkan perilaku orang yang dijalankan (jalankan). * Ketika kelas implementasi mengimplementasikan metode Dorun, Anda dapat mendengarkan aksi objek kelas orang yang dijalankan (dijalankan)* @anthor: 克克** @param e*/ void dorun (acara e);}/ *** @classname: event objek)* @description: kelas desain untuk merambat sumber acara* @Author: 克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克 克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克 克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克 克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克 @@description: tuane (克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克 克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克克. } orang publik getSource () {sumber kembali; } public void setSource (sumber orang) {this.source = sumber; }}Setelah desain seperti itu, objek kelas Peron dapat didengarkan oleh objek lain. Kode tes adalah sebagai berikut:
Paket Me.gacl.observer; kelas publik personTest { / ** * @method: main * @description: test person class * @anthor: The Arogant Wolf * * @param args * / public static void main (string [] args) {// orang p = orang baru (); // Daftarkan pendengar yang mendengarkan perilaku objek P objek P P.RegisterListener (new PersonListener () {// dengarkan p Perilaku PERUSAHAAN PUBLIK VOID DOEAT (EVENT E) {Person P = E.getSource (); System.out.println (p + "Eating");}/E.Getsource (); System.out.println (p + "Eating");}/E.geting To Pun Public Void Dor.Println (P + "EATGE");}/E.SEW TO PROUN VOID POUN VOID DOOR.PRINTLN (P + "EATGE"); System.out.println (p + "makan"); // p eating p.eat (); // p running p.run (); }}Hasil Menjalankan:
me.gacl.observer.person@4a5ab2 sedang makan me.gacl.observer.person@4a5ab2 sedang berjalan
2. Pendengar di Javaweb
2.1. Konsep Dasar
Pendengar di Javaweb adalah kelas khusus yang ditentukan dalam spesifikasi Servlet. Mereka digunakan untuk mendengarkan acara pembuatan dan penghancuran objek domain seperti ServletContext, httpsession dan ServletRequest dalam aplikasi web, serta mendengarkan acara di mana properti dalam objek domain ini dimodifikasi.
2.2. Klasifikasi pendengar servlet
Ada beberapa jenis pendengar yang ditentukan dalam spesifikasi Servlet. Sumber acara yang digunakan untuk mendengarkan adalah ServletContext, Httpsession dan ServletRequest. Spesifikasi Servlet membagi beberapa jenis pendengar menjadi tiga jenis untuk operasi pada ketiga objek ini:
• Pendengar acara yang mendengarkan penciptaan dan penghancuran objek domain itu sendiri.
• Pendengar acara yang mendengarkan untuk menambah dan menghapus properti di objek domain.
• Pendengar acara yang mendengarkan status suatu objek dalam domain httpsession.
2.3. Dengarkan Penciptaan dan Penghancuran Objek Domain ServletContext
Antarmuka ServletContextListener digunakan untuk mendengarkan acara penciptaan dan penghancuran objek ServletContext. Semua kelas yang mengimplementasikan antarmuka ServletContextListener dapat mendengarkan pembuatan dan penghancuran objek ServletContext.
• Ketika objek ServletContext dibuat, metode ContextInitialized (ServletContextEvent) dipecat.
• Ketika objek ServletContext dihancurkan, metode ContextDestroyed (ServletContextEvent) diaktifkan.
• Waktu untuk membuat dan menghancurkan objek domain ServletContext:
Buat: Startup server membuat servletContext untuk setiap aplikasi web
Penghancuran: Tutup servletContext yang mewakili setiap aplikasi web sebelum server ditutup.
Contoh: Tulis kelas MyServerContextListener, implementasikan antarmuka servletContextListener, dengarkan pembuatan dan penghancuran objek ServletContexts
1. Tulis pendengar dengan kode berikut:
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 Objek ServletContext. * @Author: The Proud Wolf* @Date: 2014-9-9 10:26:16 PM **/ Kelas Publik MySerVletContextListener mengimplementasikan servletContextListener {@Override public void contextInitialized (servletContextEvent scet) {System.out.println ("ServletContextcext (" ServletContextExtEvent) {System.out.println ("ServletContextcext (" ServletcontextExtExtExtExtExtExtEx; } @Override public void contextDestroyed (servletContextEvent scet) {System.out.println ("ServletContext Object Destruction"); }}2. Daftarkan pendengar di file web.xml
Kami menyebutkan di atas bahwa untuk mendengarkan sumber acara, Anda harus mendaftarkan pendengar ke sumber acara untuk memantau tindakan sumber acara. Di Javaweb, pendaftaran mendengarkan dikonfigurasi dalam file web.xml, sebagai berikut:
<? Xml Version = "1.0" encoding = "UTF-8"?> <Web-app Versi = "3.0" xmlns = "http://java.sun.com/xml/ns/javaee" xmlns: xsi = "http:/www.w3.org/org/2001 =" http:/www.w3.org/org/p21 XSI: schemalocation = "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee http:/--nava.sun.com/xml/ns/javaee/we-play--play <play-play> <creendak-file-list> <dreendy-filse> index.jsp </celcome-file> </celcome-file-file> <!-Daftarkan pendengar untuk mendengarkan Objek ServletContext-> <listener> <creckripe> ServletContextListener Listener </Description> <!-Kelas penerima yang mengimplementasikan servletContextListener interference-> </description> <! <listener-class> me.gacl.web.listener.myservletcontextListener </engeaner-class> </listener> </web-app>
Setelah dua langkah ini, kami telah menyelesaikan penulisan dan pendaftaran pendengar. Ketika server web dimulai, itu akan secara otomatis mendaftarkan pendengar yang dikonfigurasi di web.xml ke objek ServletContext. Dengan cara ini, pendengar MyServerContextListener yang dikembangkan dapat mendengarkan pada objek ServletContext.
2.4. Dengarkan penciptaan dan penghancuran objek domain httpsession
Antarmuka httpsessionlistener digunakan untuk mendengarkan penciptaan dan penghancuran objek httpsession. Saat membuat sesi, metode sessioncreated (httpsessionEvent SE) diaktifkan saat menghancurkan suatu sesi, dan metode sesi -stroyed (httpsessionEvent SE) diaktifkan.
Contoh: Tulis kelas MyHttpSessionListener, mengimplementasikan antarmuka httpsessionlistener, dan dengarkan penciptaan dan penghancuran objek httpsession
1. Tulis pendengar dengan kode berikut:
Paket Me.Gacl.Web.Listener; impor javax.servlet.http.httpsessionEvent; impor javax.servlet.http.httpsessionlistener;/*** @classname: kreasi myHttpsessioner* @description: The MyHttpsessionSener Class TwoCSEREY LIDRISTENGE* @Description: The MyHttpsessionSener Class TwoCSERENENEDer Menghancurkan objek httpsession dapat didengarkan. * @author: The Lonely Canglang* @date: 2014-9-9 11:04:33 pm**/ public class MyHttpSessionListener implements HttpSessionListener { @Override public void sessionCreated(HttpSessionEvent se) { System.out.println( se.getSession() + "Created!!"); }/* Waktu penghancuran httpsession perlu dikonfigurasi dalam web.xml, sebagai berikut:* <sligasi-konfigurasi> <sesi-timeout> 1 </sesi-timeout> </session-config> Konfigurasi ini berarti bahwa sesi hancur setelah 1 menit* @Override public void sessionDestrroyed (httpsespesessionSessionSessionSessionSessionSessionSessionSessionSessionSessionSessionSessionSessionSessionSessionEvente. }}2. Daftarkan pendengar di file web.xml
<!-Daftarkan pendengar untuk mendengarkan objek httpsession-> <listener> <mreccription> httpsessionlistener listener </cripence> <listener-class> me.gacl.web.listener.myhttpsessionlistener </listener> </listener> <!-mengkonfigurasi waktu untuk menghancurkan htttpspessioning> </listener> <!-Konfigurasikan waktu untuk menghancurkan Htttpspessionspessioning> </listener> <! Objek httpsession-> <sesi-config> <!-Mengkonfigurasi penghancuran objek httpsession setelah 1 menit dari objek httpsession-> <session-timeout> 1 </sesi-timeout> </session-config>
Ketika kami mengakses halaman JSP, objek HTTPSESSES akan dibuat. Pada saat ini, kita dapat mengamati proses pembuatan objek httpsession di HttpsessionListener. Kita dapat menulis halaman JSP untuk mengamati proses pembuatan objek httpsession.
Sebagai berikut: index.jsp
< %@ page language = "java" import = "java.util.*" pageEncoding = "UTF-8" %> <! Doctype html> <html> <head> <title> httpsessionlistener pendengar Anda mendengarkan httpression objek httpression </title> </head> begitu Anda mengakses jspression. ID dari sesi yang dibuat adalah: $ {pagecontext.Session.id} </body> </html>Hasil operasi adalah sebagai berikut:
2.5. Dengarkan Penciptaan dan Penghancuran Objek Domain ServletRequest
Ketika antarmuka ServletRequestListener digunakan untuk mendengarkan penciptaan dan penghancuran objek ServletRequest, metode permintaan (servletRequestEvent SRE) dari pendengar akan dipanggil. Ketika objek permintaan dihancurkan, metode requestDestroyed (servletRequestEvent SRE) dari pendengar akan dipanggil.
ServletRequest Domain Penciptaan dan Waktu Penghancuran:
Buat: Setiap kali pengguna mengunjungi, objek permintaan akan dibuat, objek permintaan akan dihancurkan: akses saat ini sudah berakhir, objek permintaan akan dihancurkan.
Contoh: Tulis kelas MySerVletRequestListener, terapkan antarmuka ServletRequestListener, dengarkan penciptaan dan penghancuran objek ServletRequest
1. Tulis pendengar dengan kode berikut:
Paket Me.Gacl.Web.Listener; impor javax.servlet.servletrequestEvent; impor javax.servlet.servletrequestlistener;/*** @classname: Kelas MyServletRequestener* @description, The MyServletRequestListener Kelas Menyampaikan The ServletRucy* @Description: The MyServletRequestListener Kelas Menyampaikan The Servletricer Of The Servletuction* Objek ServletRequest. * @author: The Proud Wolf* @date: 2014-9-9 11:50:08 pm**/ public class MyServletRequestListener implements ServletRequestListener { @Override public void requestDestroyed(ServletRequestEvent sre) { System.out.println(sre.getServletRequest() + "Destroyed!!"); } @Override public void requestInitialized (servletRequestEvent sre) {System.out.println (sre.getSerVletRequest () + "dibuat !!"); }}2. Daftarkan pendengar di file web.xml
<!-Daftarkan pendengar untuk mendengarkan Objek ServletRequest-> <listener> <creckripe> ServletRequestListener Listener </creckripe> <Distener-Class> me.gacl.web.listener.myservletrequestlistener </listener-class> </listener>
Hasil tes adalah sebagai berikut:
Dari hasil yang dijalankan, kita dapat melihat bahwa pengguna membuat objek permintaan setiap kali dia mengakses, dan objek permintaan akan dihancurkan setelah akses selesai.
Di atas adalah penjelasan singkat tentang pendengar.